## Rails 4.0.0 (unreleased) ##

* Show routes in exception page while debugging a `RoutingError` in development. *Richard Schneeman and Mattt Thompson*

* Add `ActionController::Flash.add_flash_types` method to allow people to register their own flash types. e.g.:

module AbstractController

module Translation

def translate(*args)

I18n.translate(*args)

end

alias :t :translate

end

alias :l :localize

end

def after(controller)

self.controller = controller

callback(:after) if controller.perform_caching

end

def around(controller)

before(controller)

yield

after(controller)

end

protected

end

private

def callback(timing)

controller_callback_method_name = "#{timing}_#{controller.controller_name.underscore}"

action_callback_method_name = "#{controller_callback_method_name}_#{controller.action_name}"

# end

# end

#

def respond_to(*mimes, &block)

raise ArgumentError, "respond_to takes either types or a block, never both" if mimes.any? && block_given?

# for root cases, where the latter is the correct one.

def self.normalize_path(path)

path = Journey::Router::Utils.normalize_path(path)

path

end

@path = (options[:path] || @name).to_s

@controller = (options[:controller] || @name).to_s

@as = options[:as]

@options = options

end

"#{path}/:#{param}"

end

def new_scope(new_path)

"#{path}/#{new_path}"

end

def nested_scope

end

end

def nested_options #:nodoc:

options = { :as => parent_resource.member_name }

options[:constraints] = {

options

end

end

end

def canonical_action?(action, flag) #:nodoc:

def path_for_action(action, path) #:nodoc:

prefix = shallow_scoping? ?

if canonical_action?(action, path.blank?)

prefix.to_s

end

end

def #{name}

@#{name} ||= _#{name}

end

# Creates a submit button with the text <tt>value</tt> as the caption.

#

# ==== Options

# * <tt>:disabled</tt> - If true, the user will not be able to use this input.

# * Any other key creates standard HTML options for the tag.

#

# submit_tag "Edit", :class => "edit_button"

# # => <input class="edit_button" name="commit" type="submit" value="Edit" />

#

# # => <input name='commit' type='submit' value='Save' data-confirm="Are you sure?" />

#

def submit_tag(value = "Save changes", options = {})

options = options.stringify_keys

tag :input, { "type" => "submit", "name" => "commit", "value" => value }.update(options)

end

# so this helper will also accept a block.

#

# ==== Options

# * <tt>:disabled</tt> - If true, the user will not be able to

# use this input.

# * Any other key creates standard HTML options for the tag.

options ||= {}

options = options.stringify_keys

options.reverse_merge! 'name' => 'button', 'type' => 'submit'

content_tag :button, content_or_options || 'Button', options, &block

# <tt>source</tt> is passed to AssetTagHelper#path_to_image

#

# ==== Options

# * <tt>:disabled</tt> - If set to true, the user will not be able to use this input.

# * Any other key creates standard HTML options for the tag.

#

# image_submit_tag("agree.png", :disabled => true, :class => "agree_disagree_button")

# # => <input class="agree_disagree_button" disabled="disabled" src="/images/agree.png" type="image" />

#

# # => <input src="/images/save.png" data-confirm="Are you sure?" type="image" />

def image_submit_tag(source, options = {})

options = options.stringify_keys

tag :input, { "type" => "image", "src" => path_to_image(source) }.update(options)

end

# # posts_path

#

# link_to(body, url_options = {}, html_options = {})

#

# link_to(options = {}, html_options = {}) do

# # name

# end

#

# ==== Options

# * <tt>:method => symbol of HTTP verb</tt> - This modifier will dynamically

# create an HTML form and immediately submit the form for processing using

# the HTTP verb specified. Useful for having links perform a POST operation

# link_to "Nonsense search", searches_path(:foo => "bar", :baz => "quux")

# # => <a href="/searches?foo=bar&amp;baz=quux">Nonsense search</a>

#

#

#

def link_to(name = nil, options = nil, html_options = nil, &block)

html_options, options = options, name if block_given?

options ||= {}

# to allow styling of the form itself and its children. This can be changed

# using the <tt>:form_class</tt> modifier within +html_options+. You can control

# the form submission and input element behavior using +html_options+.

# If you are using RESTful routes, you can pass the <tt>:method</tt>

# to change the HTTP verb used to submit the form.

#

# * <tt>:method</tt> - Symbol of HTTP verb. Supported verbs are <tt>:post</tt>, <tt>:get</tt>,

# <tt>:delete</tt>, <tt>:patch</tt>, and <tt>:put</tt>. By default it will be <tt>:post</tt>.

# * <tt>:disabled</tt> - If set to true, it will generate a disabled button.

# * <tt>:remote</tt> - If set to true, will allow the Unobtrusive JavaScript drivers to control the

# submit behavior. By default this behavior is an ajax submit.

# * <tt>:form</tt> - This hash will be form attributes

#

#

# <%= button_to "Delete Image", { :action => "delete", :id => @image.id },

# # => "<form method="post" action="/images/delete/1" class="button_to">

# # <div>

# # <input type="hidden" name="_method" value="delete" />

# # </form>"

#

#

# # => "<form class='button_to' method='post' action='http://www.example.com' data-remote='true'>

# # <div>

# # <input name='_method' value='delete' type='hidden' />

html_options = html_options.stringify_keys

html_options['data-remote'] = 'true' if link_to_remote_options?(options) || link_to_remote_options?(html_options)

method = html_options.delete('method')

add_method_to_attributes!(html_options, method) if method

html_options

# Helpers related to template lookup using the lookup context information.

module ViewPaths

# Whenever setting view paths, makes a copy so we can manipulate then in

# instance objects as we wish.

def formats=(values)

if values

values.concat(default_formats) if values.delete "*/*"

end

super(values)

end

def instrument(name, options={})

ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }

end

end

end

@block = block

@details = extract_details(options)

if String === partial

@object = options[:object]

@path = partial

template = determine_template(options)

context = @lookup_context

unless context.rendered_format

end

render_template(template, options[:layout], options[:locals])

def test_action_controller_base_responds_to_l

assert_respond_to @controller, :l

end

end

def show

render :text => 'hello world'

end

end

class ImplicitActionsController < ActionController::Base

assert_equal 'hello world', response.body

end

def test_before_method_of_sweeper_should_always_return_true

sweeper = ActionController::Caching::Sweeper.send(:new)

assert sweeper.before(TestController.new)

get :preview, :on => :member

end

get :details, :on => :member

resources :messages

end

scope :as => "routes" do

get "/c/:id", :as => :collision, :to => "collision#show"

get "/collision", :to => "collision#show"

assert_equal '34', @request.params[:id]

end

private

def with_https

old_https = https?

end

end

end

def test_submit_tag_with_confirmation

assert_dom_equal(

%(<input name='commit' type='submit' value='Save' data-confirm="Are you sure?" />),

)

end

assert_dom_equal('<button name="temptation" type="button"><strong>Do not press me</strong></button>', output)

end

def test_image_submit_tag_with_confirmation

assert_dom_equal(

%(<input type="image" src="/images/save.gif" data-confirm="Are you sure?" />),

)

end

assert_equal "Hello world", @view.render(:template => "test/one", :formats => [:html])

end

def test_render_template_with_a_missing_partial_of_another_format

@view.lookup_context.formats = [:html]

assert_raise ActionView::Template::Error, "Missing partial /missing with {:locale=>[:en], :formats=>[:json], :handlers=>[:erb, :builder]}" do

def test_button_to_with_javascript_confirm

assert_dom_equal(

"<form method=\"post\" action=\"http://www.example.com\" class=\"button_to\"><div><input data-confirm=\"Are you sure?\" type=\"submit\" value=\"Hello\" /></div></form>",

)

end

def test_button_to_with_remote_and_javascript_confirm

assert_dom_equal(

"<form method=\"post\" action=\"http://www.example.com\" class=\"button_to\" data-remote=\"true\"><div><input data-confirm=\"Are you sure?\" type=\"submit\" value=\"Hello\" /></div></form>",

)

end

def test_link_tag_with_javascript_confirm

assert_dom_equal(

"<a href=\"http://www.example.com\" data-confirm=\"Are you sure?\">Hello</a>",

)

assert_dom_equal(

"<a href=\"http://www.example.com\" data-confirm=\"You can't possibly be sure, can you?\">Hello</a>",

)

assert_dom_equal(

"<a href=\"http://www.example.com\" data-confirm=\"You can't possibly be sure,\n can you?\">Hello</a>",

)

end

def test_link_tag_using_post_javascript_and_confirm

assert_dom_equal(

"<a href=\"http://www.example.com\" data-method=\"post\" rel=\"nofollow\" data-confirm=\"Are you serious?\">Hello</a>",

)

end

def test_link_tag_using_delete_javascript_and_href_and_confirm

assert_dom_equal(

"<a href='\#' rel=\"nofollow\" data-confirm=\"Are you serious?\" data-method=\"delete\">Destroy</a>",

"When specifying url, form should be generated with it, but not this.href"

)

end

module Validations

module Clusivity #:nodoc:

ERROR_MESSAGE = "An object with the method #include? or a proc or lambda is required, " <<

def check_validity!

raise ArgumentError, ERROR_MESSAGE

end

end

private

def include?(record, value)

exclusions = delimiter.respond_to?(:call) ? delimiter.call(record) : delimiter

exclusions.send(inclusion_method(exclusions), value)

end

# In Ruby 1.9 <tt>Range#include?</tt> on non-numeric ranges checks all possible values in the

# range for equality, so it may be slow for large ranges. The new <tt>Range#cover?</tt>

# uses the previous logic of comparing a value with the range endpoints.

def validate_each(record, attribute, value)

if include?(record, value)

end

end

end

# * <tt>:in</tt> - An enumerable object of items that the value shouldn't

# be part of. This can be supplied as a proc or lambda which returns an

# enumerable. If the enumerable is a range the test is performed with

# <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>.

# * <tt>:message</tt> - Specifies a custom error message (default is: "is

# reserved").

def validate_each(record, attribute, value)

unless include?(record, value)

end

end

end

# supplied as a proc or lambda which returns an enumerable. If the

# enumerable is a range the test is performed with <tt>Range#cover?</tt>,

# otherwise with <tt>include?</tt>.

# * <tt>:message</tt> - Specifies a custom error message (default is: "is

# not included in the list").

# * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the

assert_equal ["option monkey is restricted"], t.errors[:title]

end

def test_validates_exclusion_of_for_ruby_class

Person.validates_exclusion_of :karma, :in => %w( abe monkey )

end

end

# validates_exclusion_of w/ mocha

COMMON_CASES.each do |name, validation_options, generate_message_options|

end

end

# validates_numericality_of without :only_integer w/ mocha

COMMON_CASES.each do |name, validation_options, generate_message_options|

assert_equal ["option uhoh is not in the list"], t.errors[:title]

end

def test_validates_inclusion_of_for_ruby_class

Person.validates_inclusion_of :karma, :in => %w( abe monkey )

## Rails 4.0.0 (unreleased) ##

* Add `add_reference` and `remove_reference` schema statements. Aliases, `add_belongs_to`

and `remove_belongs_to` are acceptable. References are reversible.

Examples:

# a +belongs_to+, and the records which get deleted are the join records, rather than

# the associated records.

#

# [:extend]

# Specify a named module for extending the proxy. See "Association extensions".

# [:include]

# has_many :tags, :as => :taggable

# has_many :reports, :readonly => true

# has_many :subscribers, :through => :subscriptions, :source => :user

Builder::HasMany.build(self, name, scope, options, &extension)

end

# has_one :boss, :readonly => :true

# has_one :club, :through => :membership

# has_one :primary_address, :through => :addressables, :conditions => ["addressable.primary = ?", true], :source => :addressable

Builder::HasOne.build(self, name, scope, options)

end

# belongs_to :post, :counter_cache => true

# belongs_to :company, :touch => true

# belongs_to :company, :touch => :employees_last_updated_at

Builder::BelongsTo.build(self, name, scope, options)

end

# such as <tt>last_name, first_name DESC</tt>

# [:uniq]

# If true, duplicate associated objects will be ignored by accessors and query methods.

# [:extend]

# Anonymous module for extending the proxy, see "Association extensions".

# [:include]

# has_and_belongs_to_many :nations, :class_name => "Country"

# has_and_belongs_to_many :categories, :join_table => "prods_cats"

# has_and_belongs_to_many :categories, :readonly => true

Builder::HasAndBelongsToMany.build(self, name, scope, options, &extension)

end

end

reset

end

# We can't dump @reflection since it contains the scope proc

def marshal_dump

reflection = @reflection

attr_reader :association, :alias_tracker

delegate :chain, :scope_chain, :options, :source_options, :active_record, :to => :reflection

def initialize(association)

@model = model

@name = name

@scope = nil

@options = scope

end

if @scope && @scope.arity == 0

CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]

def valid_options

end

attr_reader :block_extension, :extension_module

end

def valid_options

end

def build

# Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items

def ids_reader

load_target.map do |record|

record.send(reflection.association_primary_key)

end

if block_given?

load_target.find(*args) { |*block_args| yield(*block_args) }

else

end

end

end

end

# scope to the target class's +count+.

def count(column_name = nil, count_options = {})

column_name, count_options = nil, column_name if column_name.is_a?(Hash)

end

end

end

end

seen = {}

seen[record.id] = true unless seen.key?(record.id)

end

end

if record.new_record?

include_in_memory?(record)

else

loaded? ? target.include?(record) : scoped.exists?(record)

end

else

private

def find_target

records.each { |record| set_inverse_instance(record) }

records

end

# Otherwise, go to the database only if none of the following are true:

# * target already loaded

# * owner is new record

# * target contains new or changed record(s)

# * the first arg is an integer (which indicates the number of records to be returned)

def fetch_first_or_last_using_find?(args)

else

!(loaded? ||

owner.new_record? ||

target.any? { |record| record.new_record? || record.changed? } ||

args.first.kind_of?(Integer))

end

end

end

# Fetches the first/last using SQL if possible, otherwise from the target array.

def first_or_last(type, *args)

args.shift if args.first.is_a?(Hash) && args.first.empty?

end

end

record

end

end

def delete_records(records, method)

end

end

def invertible_for?(record)

# If the collection is empty the target is set to an empty array and

# the loaded flag is set to true as well.

def count_records

# If there's nothing in the database and @target has no new records

# we are certain the current target is an empty array. This is a

end

def reflection_scope

end

def build_scope

# Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and

# <tt>:updated_at</tt> to the table.

def timestamps(*args)

column(:created_at, :datetime, options)

column(:updated_at, :datetime, options)

end

join_table_name = find_join_table_name(table_1, table_2, options)

column_options = options.delete(:column_options) || {}

end

end

#

# So we can avoid the method_missing hit by explicitly defining #to_ary as nil here.

#

def to_ary # :nodoc:

nil

end

private

def find_join_table_name(table_1, table_2, options = {})

end

def join_table_name(table_1, table_2)

end

end

end

include Inheritance

include Scoping

include Sanitization

include AttributeAssignment

include ActiveModel::Conversion

include Validations

include CounterCache

include Locking::Optimistic

#

# Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"

def count_by_sql(sql)

end

end

end

active_record == other_aggregation.active_record

end

private

def derive_class_name

name.to_s.camelize

relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.send(:id))) if record.persisted?

Array(options[:scope]).each do |scope_item|

reflection = record.class.reflect_on_association(scope_item)

if reflection

scope_value = record.send(reflection.foreign_key)

end

protected

end

end

end

end

end

<%- end -%>

<%- end -%>

end

<%- else -%>

def up

<% attributes.each do |attribute| -%>

<%- end -%>

end

<%- end -%>

:foreign_key => "developer_id"

end

class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase

fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects,

:parrots, :pirates, :parrots_pirates, :treasures, :price_estimates, :tags, :taggings

assert_equal 0, david.projects(true).size

end

def test_deleting_all

david = Developer.find(1)

david.projects.reload

assert ! project.developers.include?(developer)

end

def test_find_with_merged_options

assert_equal 1, projects(:active_record).limited_developers.size

assert_equal 1, projects(:active_record).limited_developers.all.size

assert_equal 2, david.projects.count

end

def test_association_proxy_transaction_method_starts_transaction_in_association_class

Post.expects(:transaction)

Category.first.posts.transaction do

require 'models/bulb'

require 'models/engine'

class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase

fixtures :authors, :posts, :comments

assert_equal "Summit", Firm.scoped(:order => "id").first.clients_using_primary_key.first.name

end

def test_belongs_to_sanity

c = Client.new

assert_nil c.firm

assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(2, 99) }

end

def test_find_all

firm = Firm.scoped(:order => "id").first

assert_equal 2, firm.clients.scoped(:where => "#{QUOTED_TYPE} = 'Client'").all.length

assert_equal [readers(:michael_welcome).id], posts(:welcome).readers_with_person_ids

end

def test_get_ids_for_ordered_association

assert_equal [companies(:second_client).id, companies(:first_client).id], companies(:first_firm).clients_ordered_by_name_ids

end

assert ! firm.clients.loaded?

end

def test_include_returns_false_for_non_matching_record_to_verify_scoping

firm = companies(:first_firm)

client = Client.create!(:name => 'Not Associated')

def test_defining_has_many_association_with_delete_all_dependency_lazily_evaluates_target_class

ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never

class DeleteAllModel < ActiveRecord::Base

has_many :nonentities, :dependent => :delete_all

end

def test_defining_has_many_association_with_nullify_dependency_lazily_evaluates_target_class

ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never

class NullifyModel < ActiveRecord::Base

has_many :nonentities, :dependent => :nullify

end

post.taggings_with_delete_all.delete_all

end

end

end

assert post[:author_count].nil?

end

def test_primary_key_option_on_source

post = posts(:welcome)

category = categories(:general)

end

def privatize(method_signature)

private

def #{method_signature}

"I'm private"

assert_kind_of String, Client.first.to_param

end

def test_inspect_class

assert_equal 'ActiveRecord::Base', ActiveRecord::Base.inspect

assert_equal 'LoosePerson(abstract)', LoosePerson.inspect

assert_equal [cars(:honda)], result

end

def test_exec_explain_with_no_binds

sqls = %w(foo bar)

binds = [[], []]

created_at_column = created_columns.detect {|c| c.name == 'created_at' }

updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }

end

def test_create_table_with_timestamps_should_create_datetime_columns_with_options

# Do a manual insertion

if current_adapter?(:OracleAdapter)

elsif current_adapter?(:OpenBaseAdapter) || (current_adapter?(:MysqlAdapter) && Mysql.client_version < 50003) #before mysql 5.0.3 decimals stored as strings

elsif current_adapter?(:PostgreSQLAdapter)

else

end

# SELECT

end

def test_create_join_table_with_the_table_name

assert_equal %w(artist_id music_id), connection.columns(:catalog).map(&:name).sort

end

def test_create_join_table_with_the_table_name_as_string

assert_equal %w(artist_id music_id), connection.columns(:catalog).map(&:name).sort

end

def test_create_join_table_with_column_options

assert_equal [true, true], connection.columns(:artists_musics).map(&:null)

end

end

end

end

def test_reflection_of_all_associations

# FIXME these assertions bust a lot

assert_equal 10, Firm.reflect_on_all_associations(:has_one).size

assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size

end

class Thaumaturgist < IneptWizard

end

class UniquenessValidationTest < ActiveRecord::TestCase

fixtures :topics, 'warehouse-things', :developers

assert !r2.valid?, "Saving r2 first time"

end

def test_validate_uniqueness_with_object_arg

Reply.validates_uniqueness_of(:topic)

class Author < ActiveRecord::Base

has_many :posts

has_many :very_special_comments, :through => :posts

has_many :posts_containing_the_letter_a, :class_name => "Post"

has_many :posts_with_extension, :class_name => "Post" do #, :extend => ProxyTestExtension

def testing_proxy_owner

proxy_target

end

end

has_many :comments, :through => :posts

has_many :comments_containing_the_letter_e, :through => :posts, :source => :comments

has_many :first_posts

has_one :first_post

has_many :funky_comments, :through => :posts, :source => :comments

has_many :special_posts

has_many :special_post_comments, :through => :special_posts, :source => :comments

has_many :sti_posts, :class_name => 'StiPost'

has_many :sti_post_comments, :through => :sti_posts, :source => :comments

has_many :nonexistant_comments, :through => :posts

has_many :hello_post_comments, :through => :hello_posts, :source => :comments

has_many :hello_post_comments_with_hash_conditions, :through =>

:hello_posts_with_hash_conditions, :source => :comments

has_many :special_categories, :through => :special_categorizations, :source => :category

has_one :special_category, :through => :special_categorizations, :source => :category

has_many :categorized_posts, :through => :categorizations, :source => :post

has_many :nothings, :through => :kateggorisatons, :class_name => 'Category'

has_many :author_favorites

has_many :tagging, :through => :posts

has_many :taggings, :through => :posts

has_many :tags, :through => :posts

has_many :post_categories, :through => :posts, :source => :categories

has_many :tagging_tags, :through => :taggings, :source => :tag

has_many :tags_with_primary_key, :through => :posts

has_many :books

has_many :subscriptions, :through => :books

has_one :essay, :primary_key => :name, :as => :writer

has_one :essay_category, :through => :essay, :source => :category

has_many :category_post_comments, :through => :categories, :source => :post_comments

has_many :misc_post_first_blue_tags, :through => :misc_posts, :source => :first_blue_tags

has_many :posts_with_default_include, :class_name => 'PostWithDefaultInclude'

has_many :comments_on_posts_with_default_include, :through => :posts_with_default_include, :source => :comments

has_many :authors

has_many :citations, :foreign_key => 'book1_id'

has_many :subscriptions

has_many :subscribers, :through => :subscriptions

class Car < ActiveRecord::Base

has_many :bulbs

has_one :bulb

has_many :tyres

has_many :engines, :dependent => :destroy

has_and_belongs_to_many :posts

has_and_belongs_to_many :special_posts, :class_name => "Post"

has_and_belongs_to_many :other_posts, :class_name => "Post"

:class_name => 'Post',

:foreign_key => 'category_id',

has_and_belongs_to_many :post_with_conditions,

def self.what_are_you

'a category...'

has_many :post_comments, :through => :posts, :source => :comments

has_many :authors, :through => :categorizations

scope :general, -> { where(:name => 'General') }

end

end

class Firm < Company

:before_remove => :log_before_remove,

:after_remove => :log_after_remove

has_many :unsorted_clients, :class_name => "Client"

has_many :unsorted_clients_with_symbol, :class_name => :Client

has_many :unvalidated_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :validate => false

has_many :plain_clients, :class_name => 'Client'

has_many :clients_using_primary_key, :class_name => 'Client',

:primary_key => 'name', :foreign_key => 'firm_name'

has_many :clients_using_primary_key_with_delete_all, :class_name => 'Client',

:primary_key => 'name', :foreign_key => 'firm_name', :dependent => :delete_all

has_one :account, :foreign_key => "firm_id", :dependent => :destroy, :validate => true

has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => 'Account', :validate => false

# added order by id as in fixtures there are two accounts for Rails Core

# Oracle tests were failing because of that as the second fixture was selected

has_one :account_using_foreign_and_primary_keys, :foreign_key => "firm_name", :primary_key => "name", :class_name => "Account"

has_one :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete

has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false

has_many :accounts

has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false

def log

@log ||= []

end

class RestrictedFirm < Company

end

class Client < Company

belongs_to :firm, :foreign_key => "client_of"

belongs_to :firm_with_basic_id, :class_name => "Firm", :foreign_key => "firm_id"

belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"

belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"

belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name

has_many :accounts, :through => :firm

belongs_to :account

class ExclusivelyDependentFirm < Company

has_one :account, :foreign_key => "firm_id", :dependent => :delete

end

class SpecialClient < Client

end

class Firm < Company

has_one :account, :class_name => 'MyApplication::Billing::Account', :dependent => :destroy

end

end

has_and_belongs_to_many :projects_extended_by_name,

:class_name => "Project",

:join_table => "developers_projects",

has_and_belongs_to_many :projects_extended_by_name_twice,

:class_name => "Project",

:join_table => "developers_projects",

has_and_belongs_to_many :projects_extended_by_name_and_block,

:class_name => "Project",

:join_table => "developers_projects",

def find_least_recent

scoped(:order => "id ASC").first

end

class EagerDeveloperWithDefaultScope < ActiveRecord::Base

self.table_name = 'developers'

default_scope { includes(:projects) }

end

class EagerDeveloperWithClassMethodDefaultScope < ActiveRecord::Base

self.table_name = 'developers'

def self.default_scope

includes(:projects)

class EagerDeveloperWithLambdaDefaultScope < ActiveRecord::Base

self.table_name = 'developers'

default_scope lambda { includes(:projects) }

end

class EagerDeveloperWithBlockDefaultScope < ActiveRecord::Base

self.table_name = 'developers'

default_scope { includes(:projects) }

end

class EagerDeveloperWithCallableDefaultScope < ActiveRecord::Base

self.table_name = 'developers'

default_scope OpenStruct.new(:call => includes(:projects))

end

class Liquid < ActiveRecord::Base

self.table_name = :liquid

end

has_many :fellow_members, :through => :club, :source => :members

has_one :club, :through => :current_membership

has_one :selected_club, :through => :selected_membership, :source => :club

has_one :sponsor, :as => :sponsorable

has_one :sponsor_club, :through => :sponsor

has_one :member_detail

has_many :current_memberships

has_one :club_through_many, :through => :current_memberships, :source => :club

has_many :clubs, :through => :current_memberships

end

has_many :posts, :through => :readers

has_many :secure_posts, :through => :secure_readers

has_many :references

has_many :bad_references

has_many :jobs, :through => :references

has_many :jobs_with_dependent_destroy, :source => :job, :through => :references, :dependent => :destroy

def best_friend_first_name=(new_name)

assign_attributes({ :best_friend_attributes => { :first_name => new_name } })

end

class Pirate < ActiveRecord::Base

belongs_to :parrot, :validate => true

belongs_to :non_validated_parrot, :class_name => 'Parrot'

has_and_belongs_to_many :non_validated_parrots, :class_name => 'Parrot'

has_and_belongs_to_many :parrots_with_method_callbacks, :class_name => "Parrot",

:before_add => :log_before_add,

has_one :ship

has_one :update_only_ship, :class_name => 'Ship'

has_one :non_validated_ship, :class_name => 'Ship'

has_many :birds_with_method_callbacks, :class_name => "Bird",

:before_add => :log_before_add,

:after_add => :log_after_add,

:after_remove => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}

has_many :birds_with_reject_all_blank, :class_name => "Bird"

accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }

accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }

end

end

def first_comment

super.body

end

scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => 'SpecialComment'}) }

scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => 'VerySpecialComment'}) }

has_many :author_categorizations, :through => :author, :source => :categorizations

has_many :author_addresses, :through => :author

has_one :very_special_comment

has_many :special_comments

has_many :special_comments_ratings, :through => :special_comments, :source => :ratings

has_many :special_comments_ratings_taggings, :through => :special_comments_ratings, :source => :taggings

end

end

has_many :taggings_with_delete_all, :class_name => 'Tagging', :as => :taggable, :dependent => :delete_all

has_many :taggings_with_destroy, :class_name => 'Tagging', :as => :taggable, :dependent => :destroy

has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy

has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify

has_many :funky_tags, :through => :taggings, :source => :tag

has_many :super_tags, :through => :taggings

has_many :tags_with_primary_key, :through => :taggings, :source => :tag_with_primary_key

has_one :tagging, :as => :taggable

has_many :invalid_tags, :through => :invalid_taggings, :source => :tag

has_many :categorizations, :foreign_key => :category_id

has_many :readers

has_many :secure_readers

has_many :people, :through => :readers

has_many :secure_people, :through => :secure_readers

has_many :single_people, :through => :readers

:after_add => lambda {|owner, reader| log(:added, :after, reader.first_name) },

:before_remove => lambda {|owner, reader| log(:removed, :before, reader.first_name) },

:after_remove => lambda {|owner, reader| log(:removed, :after, reader.first_name) }

has_many :impatient_people, :through => :skimmers, :source => :person

def self.top(limit)

class Project < ActiveRecord::Base

has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},

:after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},

:before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},

:after_remove => Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}

attr_accessor :developers_log

after_initialize :set_developers_log

belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"

belongs_to :sponsorable, :polymorphic => true

belongs_to :thing, :polymorphic => true, :foreign_type => :sponsorable_type, :foreign_key => :sponsorable_id

end

end

class Tagging < ActiveRecord::Base

belongs_to :super_tag, :class_name => 'Tag', :foreign_key => 'super_tag_id'

belongs_to :invalid_tag, :class_name => 'Tag', :foreign_key => 'tag_id'

belongs_to :tag_with_primary_key, :class_name => 'Tag', :foreign_key => :tag_id, :primary_key => :custom_primary_key

belongs_to :taggable, :polymorphic => true, :counter_cache => true

has_many :things, :through => :taggable

end

require 'active_support/core_ext/hash/keys'

module ActiveSupport

class HashWithIndifferentAccess < Hash

def extractable_options?

true

end

# Assigns a new value to the hash:

#

# hash[:key] = "value"

#

def []=(key, value)

regular_writer(convert_key(key), convert_value(value))

end

alias_method :store, :[]=

#

#

# hash_2[:key] = "New Value!"

#

# hash_1.update(hash_2) # => {"key"=>"New Value!"}

#

def update(other_hash)

if other_hash.is_a? HashWithIndifferentAccess

super(other_hash)

# Checks the hash for a key matching the argument passed in:

#

# hash["key"] = "value"

#

def key?(key)

super(convert_key(key))

alias_method :has_key?, :key?

alias_method :member?, :key?

def fetch(key, *extras)

super(convert_key(key), *extras)

end

# Returns an array of the values at the specified indices:

#

# hash[:a] = "x"

# hash[:b] = "y"

# hash.values_at("a", "b") # => ["x", "y"]

end

end

def merge(hash)

self.dup.update(hash)

end

def reverse_merge(other_hash)

end

def reverse_merge!(other_hash)

replace(reverse_merge( other_hash ))

end

def delete(key)

super(convert_key(key))

end

def deep_symbolize_keys; to_hash.deep_symbolize_keys end

def to_options!; self end

def to_hash

Hash.new(default).merge!(self)

end

module Formatter # :nodoc:

# This method is invoked when a log event occurs

def call(severity, timestamp, progname, msg)

end

def clear!

def tags_text

tags = current_tags

if tags.any?

end

end

end

end

%w{capitalize downcase lstrip reverse rstrip swapcase upcase}.each do |method|

def test_#{method}_bang_should_return_self_when_modifying_wrapped_string

chars = ' él piDió Un bUen café '

assert_equal chars.object_id, chars.send("#{method}!").object_id

<p>

<%= link_to 'Destroy Comment', [comment.post, comment],

</p>

<td><%= post.text %></td>

<td><%= link_to 'Show', :action => :show, :id => post.id %>

<td><%= link_to 'Edit', :action => :edit, :id => post.id %>

</tr>

<% end %>

</table>

{:a => 1}.assert_valid_keys("a") # ArgumentError

</ruby>

NOTE: Defined in +active_support/core_ext/hash/keys.rb+.

<ruby>

button_to 'Delete Image', { action: 'delete', id: @image.id },

</ruby>

will produce

</html>

<ruby>

</ruby>

will produce

Note that if we wouldn't override the default behavior (POST), the above snippet would route to the create action rather than destroy.

** *JavaScript filters* You can customize the remote call further by wrapping it with some JavaScript code. Let's say in the previous example, when deleting a link, you'd like to ask for a confirmation by showing a simple modal text box to the user. This is a typical example what you can accomplish with these options - let's see them one by one:

*** +:condition+ =&gt; +code+ Evaluates +code+ (which should evaluate to a boolean) and proceeds if it's true, cancels the request otherwise.

*** +:before+ =&gt; +code+ Evaluates the +code+ just before launching the request. The output of the code has no influence on the execution. Typically used show a progress indicator (see this in action in the next example).

*** +:after+ =&gt; +code+ Evaluates the +code+ after launching the request. Note that this is different from the +:success+ or +:complete+ callback (covered in the next section) since those are triggered after the request is completed, while the code snippet passed to +:after+ is evaluated after the remote call is made. A common example is to disable elements on the page or otherwise prevent further action while the request is completed.

* Cucumber+Webrat

* Mention stuff like screw.unit/jsSpec

* +:autosave+

* +:class_name+

* +:conditions+

* +:dependent+

* +:extend+

* +:foreign_key+

* +:group+

* +:include+

end

</ruby>

h6(#has_many-dependent). +:dependent+

If you set the +:dependent+ option to +:destroy+, then deleting this object will call the +destroy+ method on the associated objects to delete those objects. If you set the +:dependent+ option to +:delete_all+, then deleting this object will delete the associated objects _without_ calling their +destroy+ method. If you set the +:dependent+ option to +:nullify+, then deleting this object will set the foreign key in the associated objects to +NULL+.

The +:extend+ option specifies a named module to extend the association proxy. Association extensions are discussed in detail <a href="#association-extensions">later in this guide</a>.

h6(#has_many-foreign_key). +:foreign_key+

By convention, Rails assumes that the column used to hold the foreign key on the other model is the name of this model with the suffix +_id+ added. The +:foreign_key+ option lets you set the name of the foreign key directly:

* +:autosave+

* +:class_name+

* +:conditions+

* +:extend+

* +:foreign_key+

* +:group+

* +:include+

* +:join_table+

* +:limit+

* +:offset+

If you use a hash-style +:conditions+ option, then record creation via this association will be automatically scoped using the hash. In this case, using +@parts.assemblies.create+ or +@parts.assemblies.build+ will create orders where the +factory+ column has the value "Seattle".

h6(#has_and_belongs_to_many-extend). +:extend+

The +:extend+ option specifies a named module to extend the association proxy. Association extensions are discussed in detail <a href="#association-extensions">later in this guide</a>.

h6(#has_and_belongs_to_many-foreign_key). +:foreign_key+

By convention, Rails assumes that the column in the join table used to hold the foreign key pointing to this model is the name of this model with the suffix +_id+ added. The +:foreign_key+ option lets you set the name of the foreign key directly:

You can use the +:include+ option to specify second-order associations that should be eager-loaded when this association is used.

h6(#has_and_belongs_to_many-join_table). +:join_table+

If the default name of the join table, based on lexical ordering, is not what you want, you can use the +:join_table+ option to override the default.

<td><%= post.text %></td>

<td><%= link_to 'Show', :action => :show, :id => post.id %></td>

<td><%= link_to 'Edit', :action => :edit, :id => post.id %></td>

</tr>

<% end %>

</table>

Here we're using +link_to+ in a different way. We wrap the

+:action+ and +:id+ attributes in a hash so that we can pass those two keys in

options are used as HTML5 attributes so that when the link is clicked,

!images/getting_started/confirm_dialog.png(Confirm Dialog)!

<p>

<%= link_to 'Destroy Comment', [comment.post, comment],

</p>

</erb>

<td><%= book.content %></td>

<td><%= link_to "Show", book %></td>

<td><%= link_to "Edit", edit_book_path(book) %></td>

</tr>

<% end %>

</table>

end

def queue #:nodoc:

end

def build_queue #:nodoc:

<% end -%>

<td><%%= link_to 'Show', <%= singular_table_name %> %></td>

<td><%%= link_to 'Edit', edit_<%= singular_table_name %>_path(<%= singular_table_name %>) %></td>

<%% end %>

</tbody>

</table>

attr_accessor :name, :type

attr_reader :attr_options

class << self

def parse(column_definition)

end

end

def human_name

end

def index_name

polymorphic? ? %w(id type).map { |t| "#{name}_#{t}" } : "#{name}_id"

else

name

end

end

def reference?

self.class.reference?(type)

end

# Do not compress assets.

config.assets.compress = false

config.assets.debug = true

<%- end -%>

require "thread"

module Rails

module Queueing

# A Queue that simply inherits from STDLIB's Queue. Everytime this

# queue is used, Rails automatically sets up a ThreadedConsumer

# to consume it.

test "the queue is a TestQueue in test mode" do

app("test")

end

test "the queue is a Queue in development mode" do

app("development")

end

class ThreadTrackingJob

test "a custom queue implementation can be provided" do

setup_custom_queue

job = Struct.new(:id, :ran) do

def run

end

end

def test_should_create_empty_migrations_if_name_not_start_with_add_or_remove

migration = "create_books"

run_generator [migration, "title:string", "content:text"]

def test_developer_options_are_overwriten_by_user_options

Rails::Generators.options[:with_options] = { :generate => false }

class WithOptionsGenerator < Rails::Generators::Base

class_option :generate, :default => true

end