Ruby on Rails

https://guides.rubyonrails.org/v4.2/
Admin
Ruby on Rails is a web application framework written in Ruby that provides a complete system for...
Tokens:324,157
Snippets:4,677
Trust Score:9.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Generate All HTML Guides

Source: https://guides.rubyonrails.org/v4.2/ruby_on_rails_guides_guidelines.html

Run this command in the `guides` directory to generate all HTML guides. Ensure Bundler is installed and updated.

```bash
bundle exec rake guides:generate
```

```bash
bundle exec rake guides:generate:html
```

--------------------------------

### Generate Specific HTML Guide

Source: https://guides.rubyonrails.org/v4.2/ruby_on_rails_guides_guidelines.html

Use the `ONLY` environment variable to generate a single guide, for example, `my_guide.md`. This is rarely needed as unmodified guides are skipped by default.

```bash
touch my_guide.md
bundle exec rake guides:generate ONLY=my_guide
```

--------------------------------

### Rails Server Startup Output

Source: https://guides.rubyonrails.org/v4.2/debugging_rails_applications.html

Example output when a Rails server starts, including version information and listening address.

```text
=> Booting WEBrick
=> Rails 4.2.0 application starting in development on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
=> Notice: server is listening on all interfaces (0.0.0.0). Consider using 127.0.0.1 (--binding option)
=> Ctrl-C to shutdown server
[2014-04-11 13:11:47] INFO  WEBrick 1.3.1
[2014-04-11 13:11:47] INFO  ruby 2.1.1 (2014-02-24) [i686-linux]
[2014-04-11 13:11:47] INFO  WEBrick::HTTPServer#start: pid=6370 port=3000
```

--------------------------------

### Install All Engine Migrations

Source: https://guides.rubyonrails.org/v4.2/engines.html

Use this command to copy migrations from all installed engines when multiple engines require migration setup.

```bash
$ rake railties:install:migrations
```

--------------------------------

### Install Gems

Source: https://guides.rubyonrails.org/v4.2/rails_application_templates.html

After adding gems to the Gemfile, run `bundle install` to install them.

```bash
bundle install
```

--------------------------------

### Setup Callback by Method Name Symbol

Source: https://guides.rubyonrails.org/v4.2/testing.html

Illustrates defining a `setup` callback using a method name specified as a symbol. This approach allows for cleaner test definitions when the setup logic is encapsulated in a separate private method.

```ruby
require 'test_helper'
class ArticlesControllerTest < ActionController::TestCase
  # called before every single test
  setup :initialize_article
  # called after every single test
  def teardown
    @article = nil
  end
  test "should show article" do
    get :show, id: @article.id
    assert_response :success
  end
  test "should update article" do
    patch :update, id: @article.id, article: {}
    assert_redirected_to article_path(assigns(:article))
  end
  test "should destroy article" do
    assert_difference('Article.count', -1) do
      delete :destroy, id: @article.id
    end
    assert_redirected_to articles_path
  end
  private
    def initialize_article
      @article = articles(:one)
    end
end
```

--------------------------------

### Install Gems and Bundle

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Remove the Bundler configuration file to allow installation of the 'db' group gems, then install all gems.

```bash
$ rm .bundle/config
```

```bash
$ bundle install
```

--------------------------------

### Install MySQL on Ubuntu

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install the MySQL server, client libraries, and development files on Ubuntu using apt-get.

```bash
$ sudo apt-get install mysql-server libmysqlclient15-dev
```

--------------------------------

### Install PostgreSQL on Ubuntu

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install the PostgreSQL server, client, contrib package, and development files on Ubuntu using apt-get.

```bash
$ sudo apt-get install postgresql postgresql-client postgresql-contrib libpq-dev
```

--------------------------------

### Setup the Database

Source: https://guides.rubyonrails.org/v4.2/active_record_migrations.html

The `rake db:setup` task creates the database, loads the schema, and initializes it with seed data.

```bash
rake db:setup
```

--------------------------------

### Install SQLite3 Development Files

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install SQLite3 and its development files, required for the 'sqlite3' gem. Installation commands vary by OS.

```bash
$ brew install sqlite3
```

```bash
$ sudo apt-get install sqlite3 libsqlite3-dev
```

```bash
$ sudo yum install sqlite3 sqlite3-devel
```

```bash
$ sudo pacman -S sqlite
```

```bash
# pkg install sqlite3
```

--------------------------------

### Install Memcached

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install and ensure memcached is running if you plan to run tests that utilize it. Installation commands vary by OS.

```bash
$ brew install memcached
```

```bash
$ sudo apt-get install memcached
```

```bash
$ sudo yum install memcached
```

```bash
$ sudo pacman -S memcached
```

```bash
# pkg install memcached
```

--------------------------------

### Install PostgreSQL on FreeBSD

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install PostgreSQL client and server packages on FreeBSD using pkg.

```bash
# pkg install postgresql93-client postgresql93-server
```

--------------------------------

### Install MySQL on FreeBSD

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install MySQL client and server packages on FreeBSD using pkg.

```bash
# pkg install mysql56-client mysql56-server
```

--------------------------------

### Install Rails 3

Source: https://guides.rubyonrails.org/v4.2/3_0_release_notes.html

Use this command to install the Rails 3 gem. You may need to use sudo depending on your system setup.

```bash
# Use sudo if your setup requires it
$ gem install rails
```

--------------------------------

### MySQL Database Configuration for Development

Source: https://guides.rubyonrails.org/v4.2/configuring.html

Example `config/database.yml` for a development environment using MySQL. Adjust username, password, and socket path as needed for your setup.

```yaml
development:
  adapter: mysql2
  encoding: utf8
  database: blog_development
  pool: 5
  username: root
  password:
  socket: /tmp/mysql.sock
```

--------------------------------

### Force Generation of All Guides

Source: https://guides.rubyonrails.org/v4.2/ruby_on_rails_guides_guidelines.html

Pass `ALL=1` to force the generation of all guides, regardless of modification status. It's recommended to also use `WARNINGS=1` to detect issues.

```bash
bundle exec rake guides:generate ALL=1 WARNINGS=1
```

--------------------------------

### Generate Kindle Guides

Source: https://guides.rubyonrails.org/v4.2/ruby_on_rails_guides_guidelines.html

Execute this rake task to generate guides specifically formatted for the Kindle.

```bash
bundle exec rake guides:generate:kindle
```

--------------------------------

### Install PostgreSQL on Arch Linux

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install the PostgreSQL server and client libraries on Arch Linux using pacman.

```bash
$ sudo pacman -S postgresql postgresql-libs
```

--------------------------------

### Install PostgreSQL on Fedora/CentOS

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install the PostgreSQL server and development files on Fedora or CentOS using yum.

```bash
$ sudo yum install postgresql-server postgresql-devel
```

--------------------------------

### Install PostgreSQL on OS X

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Use Homebrew to install the PostgreSQL server on macOS.

```bash
$ brew install postgresql
```

--------------------------------

### Example CHANGELOG Entry with Code

Source: https://guides.rubyonrails.org/v4.2/contributing_to_ruby_on_rails.html

Format for adding an entry to the CHANGELOG. Includes summary, code example, and issue reference.

```markdown
*  Summary of a change that briefly describes what was changed. You can use multiple
     lines and wrap them at around 80 characters. Code examples are ok, too, if needed:
         class Foo
           def bar
             puts 'baz'
           end
         end
     You can continue after the code example and you can attach issue number. GH#1234
    *Your Name*
```

--------------------------------

### Redirect to Index Action When Book Not Found

Source: https://guides.rubyonrails.org/v4.2/layouts_and_rendering.html

This example demonstrates using `redirect_to` instead of `render` when a record is not found. This ensures the `index` action's setup code runs.

```ruby
def index
  @books = Book.all
end
def show
  @book = Book.find_by(id: params[:id])
  if @book.nil?
    redirect_to action: :index
  end
end
```

--------------------------------

### Example Rails Template Structure

Source: https://guides.rubyonrails.org/v4.2/rails_application_templates.html

A basic example of a Rails template file demonstrating common DSL commands like generate, route, rake, and after_bundle.

```ruby
# template.rb
generate(:scaffold, "person name:string")
route "root to: 'people#index'"
rake("db:migrate")
after_bundle do 
  git :init
  git add: "."
  git commit: %Q{
-m 'Initial commit'
}
end
```

--------------------------------

### Install MySQL on OS X

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Use Homebrew to install the MySQL server on macOS.

```bash
$ brew install mysql
```

--------------------------------

### Generate Guides in a Different Language

Source: https://guides.rubyonrails.org/v4.2/ruby_on_rails_guides_guidelines.html

Use the `GUIDES_LANGUAGE` environment variable to specify the language for guide generation. Keep language-specific files in separate directories under `source`.

```bash
bundle exec rake guides:generate GUIDES_LANGUAGE=es
```

--------------------------------

### Rack::Server#start Method

Source: https://guides.rubyonrails.org/v4.2/initialization.html

This method, called via `super` in `Rails::Server#start`, handles Rack-specific server startup logic, including setting up load paths, requiring libraries, debugging options, and managing the PID file. It also sets up the INT signal trap for graceful shutdown.

```ruby
def start &blk
  if options[:warn]
    $-w = true
  end
  if includes = options[:include]
    $LOAD_PATH.unshift(*includes)
  end
  if library = options[:require]
    require library
  end
  if options[:debug]
    $DEBUG = true
    require 'pp'
    p options[:server]
    pp wrapped_app
    pp app
  end
  check_pid! if options[:pid]
  # Touch the wrapped app, so that the config.ru is loaded before
  # daemonization (i.e. before chdir, etc).
  wrapped_app
  daemonize_app if options[:daemonize]
  write_pid if options[:pid]
  trap(:INT) do
    if server.respond_to?(:shutdown)
      server.shutdown
    else
      exit
    end
  end
  server.run wrapped_app, options, &blk
end
```

--------------------------------

### Spring Status Output Example

Source: https://guides.rubyonrails.org/v4.2/4_1_release_notes.html

Example output showing the Spring server and multiple application processes running in different modes (test, development).

```text
Spring is running:
 
1182 spring server | my_app | started 29 mins ago
 
3656 spring app    | my_app | started 23 secs ago | test mode
 
3746 spring app    | my_app | started 10 secs ago | development mode
```

--------------------------------

### Install MySQL on Fedora/CentOS

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install the MySQL server and development files on Fedora or CentOS using yum.

```bash
$ sudo yum install mysql-server mysql-devel
```

--------------------------------

### Integration Test Example: Login and Browse Site

Source: https://guides.rubyonrails.org/v4.2/testing.html

This integration test simulates a user logging in via HTTPS, navigating to a page, and then browsing articles. It demonstrates using https!, get, post_via_redirect, and asserting responses and paths.

```ruby
require 'test_helper'
class UserFlowsTest < ActionDispatch::IntegrationTest
  test "login and browse site" do
    # login via https
    https!
    get "/login"
    assert_response :success
    post_via_redirect "/login", username: users(:david).username, password: users(:david).password
    assert_equal '/welcome', path
    assert_equal 'Welcome david!', flash[:notice]
    https!(false)
    get "/articles/all"
    assert_response :success
    assert assigns(:articles)
  end
end
```

--------------------------------

### Setup and Teardown Callbacks in Controller Tests

Source: https://guides.rubyonrails.org/v4.2/testing.html

Demonstrates the use of `setup` and `teardown` methods within a controller test class to prepare data before each test and clean up afterward. These methods are automatically called by the testing framework.

```ruby
require 'test_helper'
class ArticlesControllerTest < ActionController::TestCase
  # called before every single test
  def setup
    @article = articles(:one)
  end
  # called after every single test
  def teardown
    # as we are re-initializing @article before every test
    # setting it to nil here is not essential but I hope
    # you understand how you can use the teardown method
    @article = nil
  end
  test "should show article" do
    get :show, id: @article.id
    assert_response :success
  end
  test "should destroy article" do
    assert_difference('Article.count', -1) do
      delete :destroy, id: @article.id
    end
    assert_redirected_to articles_path
  end
end
```

--------------------------------

### Controller Code Example

Source: https://guides.rubyonrails.org/v4.2/command_line.html

This is an example of a generated controller file. It defines an action and sets an instance variable to be used in the view.

```ruby
class GreetingsController < ApplicationController
  def hello
    @message = "Hello, how are you today?"
  end
end
```

--------------------------------

### Install Dependencies with Bundler

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install all project dependencies using Bundler, excluding MySQL and PostgreSQL Ruby drivers. This prepares the environment for running tests.

```bash
$ bundle install --without db
```

--------------------------------

### Verify Ruby Installation

Source: https://guides.rubyonrails.org/v4.2/getting_started.html

Run this command to check if Ruby is installed and display its version. Ensure you have a compatible version.

```bash
$ ruby -v
```

--------------------------------

### Register Callback After Bundle Install

Source: https://guides.rubyonrails.org/v4.2/rails_application_templates.html

Defines a block of code to be executed after `bundle install` and binstub generation. Useful for post-installation Git operations.

```ruby
after_bundle do
  git :init
  git add: '.'
  git commit: "-a -m 'Initial commit'"
end
```

--------------------------------

### Full Functional Test Example with Flash and Redirect

Source: https://guides.rubyonrails.org/v4.2/testing.html

This example demonstrates a full functional test including asserting the creation of an article, checking the redirect, and verifying the flash message.

```ruby
test "should create article" do
  assert_difference('Article.count') do
    post :create, article: {title: 'Hi', body: 'This is my first article.'}
  end
  assert_redirected_to article_path(assigns(:article))
  assert_equal 'Article was successfully created.', flash[:notice]
end
```

--------------------------------

### View Code Example

Source: https://guides.rubyonrails.org/v4.2/command_line.html

This is an example of a generated view file. It displays a heading and renders an instance variable passed from the controller.

```erb
<%= @message %>
</p>
```

--------------------------------

### Start Rails Server

Source: https://guides.rubyonrails.org/v4.2/command_line.html

Use the `rails server` command to start the WEBrick web server. This command is used to run the Rails application locally.

```bash
$ bin/rails server
=> Booting WEBrick...
```

--------------------------------

### Example Payment Configuration in YAML

Source: https://guides.rubyonrails.org/v4.2/configuring.html

Define environment-specific payment gateway configurations in a YAML file.

```yaml
production:
  environment: production
  merchant_id: production_merchant_id
  public_key:  production_public_key
  private_key: production_private_key
development:
  environment: sandbox
  merchant_id: development_merchant_id
  public_key:  development_public_key
  private_key: development_private_key
```

--------------------------------

### Example Rails Middleware Stack

Source: https://guides.rubyonrails.org/v4.2/rails_on_rack.html

An example output of the `bin/rake middleware` task, showing the default middlewares used by a Rails application.

```text
use Rack::Sendfile
use ActionDispatch::Static
use Rack::Lock
use #<ActiveSupport::Cache::Strategy::LocalCache::Middleware:0x000000029a0838>
use Rack::Runtime
use Rack::MethodOverride
use ActionDispatch::RequestId
use Rails::Rack::Logger
use ActionDispatch::ShowExceptions
use ActionDispatch::DebugExceptions
use ActionDispatch::RemoteIp
use ActionDispatch::Reloader
use ActionDispatch::Callbacks
use ActiveRecord::Migration::CheckPending
use ActiveRecord::ConnectionAdapters::ConnectionManagement
use ActiveRecord::QueryCache
use ActionDispatch::Cookies
use ActionDispatch::Session::CookieStore
use ActionDispatch::Flash
use ActionDispatch::ParamsParser
use Rack::Head
use Rack::ConditionalGet
use Rack::ETag
run Rails.application.routes
```

--------------------------------

### Validate Generated HTML Guides

Source: https://guides.rubyonrails.org/v4.2/ruby_on_rails_guides_guidelines.html

Run this command to validate the generated HTML guides. Set `WARNINGS=1` during generation to detect duplicate IDs and broken links.

```bash
bundle exec rake guides:validate
```

--------------------------------

### Installing a Single Gem with Rake

Source: https://guides.rubyonrails.org/v4.2/2_2_release_notes.html

Specifies how to install or unpack a single gem by providing its name on the command line.

```bash
GEM=_gem_name_ rake gems:install
```

--------------------------------

### Get Beginning or End of Week

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Use `beginning_of_week` and `end_of_week` to get the dates for the start and end of the week. By default, weeks start on Monday, but this can be changed by passing an argument or setting `Date.beginning_of_week`. `at_beginning_of_week` and `at_end_of_week` are aliases.

```ruby
d = Date.new(2010, 5, 8)     
# => Sat, 08 May 2010
d.beginning_of_week          
# => Mon, 03 May 2010
d.beginning_of_week(:sunday) 
# => Sun, 02 May 2010
d.end_of_week                
# => Sun, 09 May 2010
d.end_of_week(:sunday)       
# => Sat, 08 May 2010
```

--------------------------------

### Product Partial Example

Source: https://guides.rubyonrails.org/v4.2/layouts_and_rendering.html

This is an example of a partial that renders a single product's name. It assumes a 'product' object is available in the rendering context.

```erb
<p>Product Name: <%= product.name %></p>
```

--------------------------------

### Install Bundler

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install or update Bundler, a dependency manager for Ruby projects. Use these commands to get a recent version.

```bash
$ gem install bundler
```

```bash
$ gem update bundler
```

--------------------------------

### Example YAML Translations for Dates

Source: https://guides.rubyonrails.org/v4.2/i18n.html

An example of a YAML file storing date format translations, demonstrating nested keys for different formats.

```yaml
en:
  date:
    formats:
      default: "%Y-%m-%d"
      short: "%b %d"
      long: "%B %d, %Y"
```

--------------------------------

### Get Beginning or End of Quarter

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Use `beginning_of_quarter` and `end_of_quarter` to get the dates for the start and end of the quarter. `at_beginning_of_quarter` and `at_end_of_quarter` are aliases.

```ruby
d = Date.new(2010, 5, 9) 
# => Sun, 09 May 2010
d.beginning_of_quarter   
# => Thu, 01 Apr 2010
d.end_of_quarter         
# => Wed, 30 Jun 2010
```

--------------------------------

### Rails::Server#start Method

Source: https://guides.rubyonrails.org/v4.2/initialization.html

This method initiates the server startup process, including setting up signal traps, creating temporary directories, and logging. It then calls the superclass method to continue the Rack server initialization.

```ruby
def start
  print_boot_information
  trap(:INT) { exit }
  create_tmp_directories
  log_to_stdout if options[:log_stdout]
  super
  ...
end
```

```ruby
private
  def print_boot_information
    ...
    puts "=> Run `rails server -h` for more startup options"
    ...
    puts "=> Ctrl-C to shutdown server" unless options[:daemonize]
  end
```

```ruby
  def create_tmp_directories
    %w(cache pids sessions sockets).each do |dir_to_make|
      FileUtils.mkdir_p(File.join(Rails.root, 'tmp', dir_to_make))
    end
  end
```

```ruby
  def log_to_stdout
    wrapped_app # touch the app so the logger is set up
    console = ActiveSupport::Logger.new($stdout)
    console.formatter = Rails.logger.formatter
    console.level = Rails.logger.level
    Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
  end
```

--------------------------------

### Get Beginning and End of Year

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Use `beginning_of_year` and `end_of_year` to get the dates for the start and end of the year. `beginning_of_year` is aliased to `at_beginning_of_year`, and `end_of_year` is aliased to `at_end_of_year`.

```ruby
d = Date.new(2010, 5, 9) 
# => Sun, 09 May 2010
d.beginning_of_year       
# => Fri, 01 Jan 2010
d.end_of_year             
# => Fri, 31 Dec 2010
```

--------------------------------

### Aircraft Initialization with Flight Model

Source: https://guides.rubyonrails.org/v4.2/autoloading_and_reloading_constants.html

An example of an aircraft class initializing its flight model.

```ruby
# app/models/bell_x1/aircraft.rb
module BellX1
  class Aircraft
    def initialize
      @flight_model ||= FlightModel.new
    end
  end
end
```

--------------------------------

### Install MariaDB on Arch Linux

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Install MariaDB server, client libraries, and clients on Arch Linux using pacman. MySQL is no longer supported.

```bash
$ sudo pacman -S mariadb libmariadbclient mariadb-clients
```

--------------------------------

### Model Definitions

Source: https://guides.rubyonrails.org/v4.2/active_record_querying.html

Example model definitions used throughout the guide. These models define associations and database interactions.

```ruby
class Client < ActiveRecord::Base
  has_one :address
  has_many :orders
  has_and_belongs_to_many :roles
end
```

```ruby
class Address < ActiveRecord::Base
  belongs_to :client
end
```

```ruby
class Order < ActiveRecord::Base
  belongs_to :client, counter_cache: true
end
```

```ruby
class Role < ActiveRecord::Base
  has_and_belongs_to_many :clients
end
```

--------------------------------

### Basic Fragment Caching Example

Source: https://guides.rubyonrails.org/v4.2/caching_with_rails.html

This example shows how to cache a section of a view that lists available products, while other parts remain dynamic. The `cache` block wraps the content to be cached.

```erb
<% Order.find_recent.each do |o| %>
  <%= o.buyer.name %> bought <%= o.product.name %>
<% end %>
<% cache do %>
  All available products:
  <% Product.all.each do |p| %>
    <%= link_to p.name, product_url(p) %>
  <% end %>
<% end %>
```

--------------------------------

### Start Rails Development Server

Source: https://guides.rubyonrails.org/v4.2/getting_started.html

Run this command in your application's root directory to start the WEBrick web server. For Windows, use 'ruby bin\rails server'. Changes in development mode are usually picked up automatically without a server restart.

```bash
$ bin/rails server
```

```bash
ruby bin\rails server
```

--------------------------------

### Get Parent Chain with parents

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

The parents method returns an array of all parent modules, starting from the immediate parent up to Object.

```ruby
module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z
X::Y::Z.parents # => [X::Y, X, Object]
M.parents       # => [X::Y, X, Object]
```

--------------------------------

### Rails Server Initialization

Source: https://guides.rubyonrails.org/v4.2/rails_on_rack.html

Shows how `rails server` creates a `Rack::Server` object and starts the webserver.

```ruby
Rails::Server.new.tap do |server|  require APP_PATH  Dir.chdir(Rails.application.root)  server.startend
```

--------------------------------

### Route with Segment Constraints (Anchored Implicitly)

Source: https://guides.rubyonrails.org/v4.2/routing.html

Routes are implicitly anchored at the start. This example shows how to match numeric IDs and non-numeric usernames.

```ruby
get '/:id', to: 'articles#show', constraints: { id: /\d.+/ }get '/:username', to: 'users#show'
```

--------------------------------

### Setup for `acts_as_yaffle` Method

Source: https://guides.rubyonrails.org/v4.2/plugins.html

Prepare the necessary files for implementing an `acts_as_yaffle` method in Active Record. This includes creating a test file and updating the main plugin file to require the new extension.

```ruby
# yaffle/test/acts_as_yaffle_test.rb
require 'test_helper'
class ActsAsYaffleTest < ActiveSupport::TestCase
end
```

```ruby
# yaffle/lib/yaffle.rb
require 'yaffle/core_ext'
require 'yaffle/acts_as_yaffle'
module Yaffle
end
```

```ruby
# yaffle/lib/yaffle/acts_as_yaffle.rb
module Yaffle
  module ActsAsYaffle
    # your code will go here
  end
end
```

--------------------------------

### Controller Functional Test Without Route Setup

Source: https://guides.rubyonrails.org/v4.2/engines.html

This is an example of a controller functional test that may not work correctly in an engine context without proper route configuration.

```ruby
module Blorgh
  class FooControllerTest < ActionController::TestCase
    def test_index
      get :index
      ...
    end
  end
end
```

--------------------------------

### Get Substring from Position

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Returns the substring starting from a specific position to the end of the string. Supports positive and negative indices. Returns an empty string or nil for out-of-bounds positions.

```ruby
"hello".from(0) # => "hello"
"hello".from(2) # => "llo"
"hello".from(-2) # => "lo"
"hello".from(10) # => "" if < 1.9, nil in 1.9
```

--------------------------------

### Method Arrays for Member or Collection Routes in Rails

Source: https://guides.rubyonrails.org/v4.2/2_2_release_notes.html

Define member or collection routes to accept multiple HTTP methods by providing an array of verbs. This example sets up a search route for photos that accepts both GET and POST.

```ruby
map.resources :photos, :collection => { :search => [:get, :post] }
```

--------------------------------

### Springify Binstubs

Source: https://guides.rubyonrails.org/v4.2/upgrading_ruby_on_rails.html

After adding Spring to your Gemfile and running `bundle install`, springify your binstubs using this command.

```bash
bundle exec spring binstub --all
```

--------------------------------

### config/application.rb

Source: https://guides.rubyonrails.org/v4.2/initialization.html

This file is responsible for the core Rails application setup. It includes the `config/boot.rb` file to ensure necessary components are loaded.

```ruby
require File.expand_path('../boot', __FILE__)
```

--------------------------------

### Installing Missing Gems with Rake

Source: https://guides.rubyonrails.org/v4.2/2_2_release_notes.html

Command to install gems that are required by the Rails application but are not currently installed.

```bash
rake gems:install
```

--------------------------------

### Verify Rails Installation

Source: https://guides.rubyonrails.org/v4.2/getting_started.html

Confirm that Rails has been installed successfully by checking its version. A version number indicates a successful installation.

```bash
$ rails --version
```

--------------------------------

### Create Rails App with Git and PostgreSQL

Source: https://guides.rubyonrails.org/v4.2/command_line.html

This command initializes a new Rails application in the current directory, configuring it to use Git for source control and PostgreSQL as the database. Ensure the directory exists and Git is initialized before running.

```bash
$ mkdir gitapp
$ cd gitapp
$ git init
Initialized empty Git repository in .git/
$ rails new . --git --database=postgresql
```

--------------------------------

### Building the Rack App

Source: https://guides.rubyonrails.org/v4.2/initialization.html

This snippet shows how the `@wrapped_app` is built, either from a string or by parsing a configuration file. It ensures the application's Rack interface is ready before server execution.

```ruby
@wrapped_app ||= build_app app
```

--------------------------------

### Install Rails Gem

Source: https://guides.rubyonrails.org/v4.2/getting_started.html

Use the RubyGems package manager to install the Rails framework. This command fetches and installs the latest stable version.

```bash
$ gem install rails
```

--------------------------------

### View Plugin Generator Options

Source: https://guides.rubyonrails.org/v4.2/engines.html

To see all available options for the plugin generator, run the help command.

```bash
$ rails plugin --help
```

--------------------------------

### Generate Rails Guides Locally

Source: https://guides.rubyonrails.org/v4.2/2_2_release_notes.html

Use this rake task to generate the Rails Guides locally within your application. The guides will be placed in `Rails.root/doc/guides` and can be accessed by opening `Rails.root/doc/guides/index.html` in your browser.

```ruby
rake doc:guides
```

--------------------------------

### Install byebug Gem

Source: https://guides.rubyonrails.org/v4.2/debugging_rails_applications.html

Run this command in your terminal to install the byebug gem.

```bash
$ gem install byebug
```

--------------------------------

### Add Development Gem Dependency to Engine

Source: https://guides.rubyonrails.org/v4.2/engines.html

Use `s.add_development_dependency` in the `.gemspec` file for gems needed only during development or testing of the engine. These are not installed with a standard `gem install` but are included with `bundle install` in the application.

```ruby
s.add_development_dependency "moo"
```

--------------------------------

### Bundler Setup in config/boot.rb

Source: https://guides.rubyonrails.org/v4.2/initialization.html

This snippet from `config/boot.rb` sets the `BUNDLE_GEMFILE` environment variable to the application's `Gemfile` and then requires `bundler/setup` if the `Gemfile` exists. This ensures that all gem dependencies are loaded correctly.

```ruby
# Set up gems listed in the Gemfile.
ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
```

--------------------------------

### Module and Class Nesting Example

Source: https://guides.rubyonrails.org/v4.2/autoloading_and_reloading_constants.html

Demonstrates how to define nested modules and classes and inspect their nesting using `Module.nesting`.

```ruby
module XML
  class SAXParser
    # (1)
  end
end
```

```ruby
[XML::SAXParser, XML]
```

```ruby
class XML::SAXParser
  # (2)
end
```

```ruby
[XML::SAXParser]
```

```ruby
module X
  module Y
  end
end
module A
  module B
  end
end
module X::Y
  module A::B
    # (3)
  end
end
```

```ruby
[A::B, X::Y]
```

--------------------------------

### Build App from Configuration File

Source: https://guides.rubyonrails.org/v4.2/initialization.html

Builds the Rack application and merges options by parsing a configuration file. Ensures the configuration file exists before parsing.

```ruby
def build_app_and_options_from_config
    if !::File.exist? options[:config]
      abort "configuration #{options[:config]} not found"
    end 
    app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
    self.options.merge! options
    app
  end
```

--------------------------------

### Render Index Template with Flash Alert

Source: https://guides.rubyonrails.org/v4.2/layouts_and_rendering.html

This example shows how to directly render the `index` template when a book is not found, while also setting an instance variable and a flash alert message. This avoids an extra browser round trip.

```ruby
def index
  @books = Book.all
end
def show
  @book = Book.find_by(id: params[:id])
  if @book.nil?
    @books = Book.all
    flash.now[:alert] = "Your book was not found"
    render "index"
  end
end
```

--------------------------------

### Create a Product Table Schema

Source: https://guides.rubyonrails.org/v4.2/active_record_basics.html

Example SQL for creating a 'products' table with an auto-incrementing primary key.

```sql
CREATE TABLE products (
    id int(11) NOT NULL auto_increment,
    name varchar(255),
    PRIMARY KEY (id)
);
```

--------------------------------

### CSRF Protection for GET Requests with JS Responses

Source: https://guides.rubyonrails.org/v4.2/upgrading_ruby_on_rails.html

Functional and integration tests using `get :index, format: :js` will now trigger CSRF protection. Use `xhr :get, :index, format: :js` to explicitly test an XmlHttpRequest.

```ruby
get :index, format: :js
```

```ruby
xhr :get, :index, format: :js
```

--------------------------------

### Initialize and Save Article in Controller

Source: https://guides.rubyonrails.org/v4.2/getting_started.html

Use this to initialize a new Article instance with parameters and save it to the database. Redirects to the article's show page upon successful save.

```ruby
def create
  @article = Article.new(params[:article])
  @article.save
  redirect_to @article
end
```

--------------------------------

### Display Generator Help Information

Source: https://guides.rubyonrails.org/v4.2/generators.html

View the usage instructions and available options for a specific generator using the --help flag. This is useful for understanding how to invoke the generator.

```bash
$ bin/rails generate initializer --help
```

--------------------------------

### Seed Database with Products

Source: https://guides.rubyonrails.org/v4.2/active_record_migrations.html

Populates the `db/seeds.rb` file with Ruby code to create initial product data. Run with `rake db:seed`.

```ruby
5.times do |i|
  Product.create(name: "Product ##{i}", description: "A product.")
end
```

--------------------------------

### Render Index Action

Source: https://guides.rubyonrails.org/v4.2/layouts_and_rendering.html

This example shows how `render` is used to display a view. If a book is not found, it renders the 'index' action.

```ruby
def index
  @books = Book.all
end
def show
  @book = Book.find_by(id: params[:id])
  if @book.nil?
    render action: "index"
  end
end
```

--------------------------------

### Verify SQLite3 Installation

Source: https://guides.rubyonrails.org/v4.2/getting_started.html

Check if SQLite3 is installed and accessible in your system's PATH. This database is commonly used with Rails.

```bash
$ sqlite3 --version
```

--------------------------------

### Migrate Database for Dummy App

Source: https://guides.rubyonrails.org/v4.2/plugins.html

Navigate to the dummy Rails application directory and run the database migration command to create the necessary tables for the generated models.

```bash
$ cd test/dummy
$ bin/rake db:migrate
```

--------------------------------

### Rack::Builder#initialize and config.ru

Source: https://guides.rubyonrails.org/v4.2/initialization.html

Demonstrates how `Rack::Builder.parse_file` processes the `config.ru` file to construct the Rack application. It highlights the `eval` call within `new_from_string` which executes the builder script.

```ruby
# This file is used by Rack-based servers to start the application.
require ::File.expand_path('../config/environment', __FILE__)
run <%= app_const %>
```

```ruby
app = new_from_string cfgfile, config
...

def self.new_from_string(builder_script, file="(rackup)")
  eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
       TOPLEVEL_BINDING, file, 0
end
```

--------------------------------

### Generate Application Documentation

Source: https://guides.rubyonrails.org/v4.2/command_line.html

Generate documentation for your Rails application, guides, and API using Rake tasks. `rake doc:app` creates documentation in `doc/app`, `rake doc:guides` for Rails guides in `doc/guides`, and `rake doc:rails` for API docs in `doc/api`.

```shell
rake doc:app
```

```shell
rake doc:guides
```

```shell
rake doc:rails
```

--------------------------------

### Integration Test with Multiple Sessions and Custom DSL

Source: https://guides.rubyonrails.org/v4.2/testing.html

This example showcases advanced integration testing by managing multiple user sessions simultaneously and defining a custom DSL for common actions like browsing the site. It uses open_session to create independent test environments.

```ruby
require 'test_helper'
class UserFlowsTest < ActionDispatch::IntegrationTest
  test "login and browse site" do
    # User david logs in
    david = login(:david)
    # User guest logs in
    guest = login(:guest)
    # Both are now available in different sessions
    assert_equal 'Welcome david!', david.flash[:notice]
    assert_equal 'Welcome guest!', guest.flash[:notice]
    # User david can browse site
    david.browses_site
    # User guest can browse site as well
    guest.browses_site
    # Continue with other assertions
  end
  private
    module CustomDsl
      def browses_site
        get "/products/all"
        assert_response :success
        assert assigns(:products)
      end
    end
    def login(user)
      open_session do |sess|
        sess.extend(CustomDsl)
        u = users(user)
        sess.https!
        sess.post "/login", username: u.username, password: u.password
        assert_equal '/welcome', sess.path
        sess.https!(false)
      end
    end
end
```

--------------------------------

### Get Previous Monday or Next Sunday

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Use `monday` to get the date of the previous Monday and `sunday` to get the date of the next Sunday. If the current date is a Monday, `monday` returns the current date. If the current date is a Sunday, `sunday` returns the current date.

```ruby
d = Date.new(2010, 5, 8)     
# => Sat, 08 May 2010
d.monday                   
# => Mon, 03 May 2010
d.sunday                   
# => Sun, 09 May 2010
```

```ruby
d = Date.new(2012, 9, 10)    
# => Mon, 10 Sep 2012
d.monday                   
# => Mon, 10 Sep 2012
```

```ruby
d = Date.new(2012, 9, 16)    
# => Sun, 16 Sep 2012
d.sunday                   
# => Sun, 16 Sep 2012
```

--------------------------------

### Get Help for a Specific Rails Generator

Source: https://guides.rubyonrails.org/v4.2/generators.html

Use the --help flag with any generator to get detailed information about its usage and options.

```bash
$ bin/rails generate helper --help
```

--------------------------------

### Database Configuration with Connection Pooling

Source: https://guides.rubyonrails.org/v4.2/2_2_release_notes.html

Example `database.yml` configuration for the development environment, specifying the adapter, username, database name, connection pool size, and wait timeout.

```yaml
development:
  adapter: mysql
  username: root
  database: sample_development
  pool: 10
  wait_timeout: 10
```

--------------------------------

### Basic Assertion Example

Source: https://guides.rubyonrails.org/v4.2/testing.html

An assertion checks for expected results. This example uses 'assert true', which will always pass, serving as a placeholder.

```ruby
assert true
```

--------------------------------

### Starting the Byebug Debugger Shell

Source: https://guides.rubyonrails.org/v4.2/debugging_rails_applications.html

When byebug is called in your code, it starts a debugger shell in the terminal. The current line is marked with '=>'.

```ruby
[1, 10] in /PathTo/project/app/controllers/articles_controller.rb"
        3:
        4:  # GET /articles
        5:  # GET /articles.json
        6:  def index
        7:    byebug
=>    8:    @articles = Article.find_recent
        9:
       10:    respond_to do |format|
       11:      format.html # index.html.erb
       12:      format.json { render json: @articles }
```

--------------------------------

### Create Initial Products Migration

Source: https://guides.rubyonrails.org/v4.2/active_record_migrations.html

Defines an `up` method to create initial products and a `down` method to delete them. Use this for adding data via migrations.

```ruby
class AddInitialProducts < ActiveRecord::Migration
  def up
    5.times do |i|
      Product.create(name: "Product ##{i}", description: "A product.")
    end
  end

  def down
    Product.delete_all
  end
end
```

--------------------------------

### Installing a Plugin with a Specific Revision

Source: https://guides.rubyonrails.org/v4.2/2_2_release_notes.html

Command to install a Rails plugin, supporting git and svn repositories, and allowing specification of a particular revision.

```bash
script/plugin install <plugin> -r <revision>
```

--------------------------------

### Create Table with Database Options

Source: https://guides.rubyonrails.org/v4.2/active_record_migrations.html

Use the `options` argument in `create_table` to pass database-specific SQL fragments, such as storage engines.

```ruby
create_table :products, options: "ENGINE=BLACKHOLE" do |t|
  t.string :name, null: false
end
```

--------------------------------

### Rails::Server OptionParser Setup

Source: https://guides.rubyonrails.org/v4.2/initialization.html

Sets up the OptionParser for Rails server, defining usage and specific options like port, with a default value.

```ruby
def parse!(args)
  args, options = args.dup, {}
  opt_parser = OptionParser.new
    do |opts|
    opts.banner = "Usage: rails server [mongrel, thin, etc] [options]"
    opts.on("-p", "--port=port", Integer,
            "Runs Rails on the specified port.",
            "Default: 3000") { |v| options[:Port] = v }
  ...
end
```

--------------------------------

### Rack::Server Initialize Method

Source: https://guides.rubyonrails.org/v4.2/initialization.html

The initialize method in Rack::Server sets up instance variables for options and the application. It's called during server startup.

```ruby
def initialize(options = nil)
  @options = options
  @app = options[:app] if options && options[:app]
end
```

--------------------------------

### Install Rails Upgrade Plugin

Source: https://guides.rubyonrails.org/v4.2/3_0_release_notes.html

Use this command to install the Rails Upgrade plugin, which helps automate parts of the upgrade process to Rails 3.0.

```bash
$ ruby script/plugin install git://github.com/rails/rails_upgrade.git
```

--------------------------------

### Get Beginning and End of Day Timestamps

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Use `beginning_of_day` to get a timestamp at 00:00:00 and `end_of_day` for 23:59:59. `beginning_of_day` is aliased to `at_beginning_of_day`, `midnight`, and `at_midnight`.

```ruby
date = Date.new(2010, 6, 7)
date.beginning_of_day 
# => Mon Jun 07 00:00:00 +0200 2010
```

```ruby
date = Date.new(2010, 6, 7)
date.end_of_day 
# => Mon Jun 07 23:59:59 +0200 2010
```

--------------------------------

### Test Plugin Generation

Source: https://guides.rubyonrails.org/v4.2/plugins.html

After generating a plugin, navigate to its directory, run `bundle install`, and then execute `rake` to run the default tests. A successful run indicates proper generation.

```bash
bundle install
rake
```

--------------------------------

### Get Beginning or End of Month

Source: https://guides.rubyonrails.org/v4.2/active_support_core_extensions.html

Use `beginning_of_month` and `end_of_month` to get the dates for the first and last day of the month, respectively. `at_beginning_of_month` and `at_end_of_month` are aliases.

```ruby
d = Date.new(2010, 5, 9) 
# => Sun, 09 May 2010
d.beginning_of_month     
# => Sat, 01 May 2010
d.end_of_month           
# => Mon, 31 May 2010
```

--------------------------------

### Autoloading Error Message Example

Source: https://guides.rubyonrails.org/v4.2/autoloading_and_reloading_constants.html

This is an example of a `LoadError` that Rails might raise if a constant cannot be autoloaded. It indicates the expected file path and the constant that was not defined.

```text
unable to autoload constant ApplicationController, expected<full path to application_controller.rb> to define it (LoadError)
```

--------------------------------

### Create All Test Databases

Source: https://guides.rubyonrails.org/v4.2/development_dependencies_install.html

Navigate to the activerecord directory and use the Rake task to create test databases for both PostgreSQL and MySQL.

```bash
$ cd activerecord
```

```bash
$ bundle exec rake db:create
```

--------------------------------

### Router Configuration for Rack Apps and String Controllers

Source: https://guides.rubyonrails.org/v4.2/4_2_release_notes.html

Demonstrates the updated syntax for configuring routes to Rack applications or string-based controllers. No change is necessary for existing configurations that use the new format.

```ruby
get '/posts', to: MyRackApp
get '/posts', to: 'post#index'
get '/posts', to: 'posts'
get '/posts', action: :index
```

--------------------------------

### Engine Initialization File

Source: https://guides.rubyonrails.org/v4.2/engines.html

This file requires the engine's engine.rb and defines the base module for the engine. It's a good place for global configuration options.

```ruby
require "blorgh/engine"
module Blorgh
end
```
Tokens:
Raw