usher 0.7.0 → 0.7.1

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/pkg/activerecord-2.3.3/lib/active_record/named_scope.rb

@@ -1,197 +0,0 @@
-module ActiveRecord
-  module NamedScope
-    # All subclasses of ActiveRecord::Base have one named scope:
-    # * <tt>scoped</tt> - which allows for the creation of anonymous \scopes, on the fly: <tt>Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)</tt>
-    #
-    # These anonymous \scopes tend to be useful when procedurally generating complex queries, where passing
-    # intermediate values (scopes) around as first-class objects is convenient.
-    #
-    # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
-    def self.included(base)
-      base.class_eval do
-        extend ClassMethods
-        named_scope :scoped, lambda { |scope| scope }
-      end
-    end
-
-    module ClassMethods
-      def scopes
-        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
-      end
-
-      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
-      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'}
-      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
-      #   end
-      # 
-      # The above calls to <tt>named_scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red, 
-      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
-      #
-      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it resembles the association object
-      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
-      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
-      # as with the association objects, named \scopes act like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
-      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really was an Array.
-      #
-      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
-      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
-      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
-      #
-      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which the \scopes were defined. But they are also available to
-      # <tt>has_many</tt> associations. If,
-      #
-      #   class Person < ActiveRecord::Base
-      #     has_many :shirts
-      #   end
-      #
-      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
-      # only shirts.
-      #
-      # Named \scopes can also be procedural:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
-      #       { :conditions => { :color => color } }
-      #     }
-      #   end
-      #
-      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
-      #
-      # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :red, :conditions => {:color => 'red'} do
-      #       def dom_id
-      #         'red_shirts'
-      #       end
-      #     end
-      #   end
-      #
-      #
-      # For testing complex named \scopes, you can examine the scoping options using the
-      # <tt>proxy_options</tt> method on the proxy itself.
-      #
-      #   class Shirt < ActiveRecord::Base
-      #     named_scope :colored, lambda { |color|
-      #       { :conditions => { :color => color } }
-      #     }
-      #   end
-      #
-      #   expected_options = { :conditions => { :colored => 'red' } }
-      #   assert_equal expected_options, Shirt.colored('red').proxy_options
-      def named_scope(name, options = {}, &block)
-        name = name.to_sym
-        scopes[name] = lambda do |parent_scope, *args|
-          Scope.new(parent_scope, case options
-            when Hash
-              options
-            when Proc
-              case parent_scope
-              when Scope
-                with_scope(:find => parent_scope.proxy_options) { options.call(*args) }
-              else
-                options.call(*args)
-              end
-          end, &block)
-        end
-        (class << self; self end).instance_eval do
-          define_method name do |*args|
-            scopes[name].call(self, *args)
-          end
-        end
-      end
-    end
-
-    class Scope
-      attr_reader :proxy_scope, :proxy_options, :current_scoped_methods_when_defined
-      NON_DELEGATE_METHODS = %w(nil? send object_id class extend find size count sum average maximum minimum paginate first last empty? any? respond_to?).to_set
-      [].methods.each do |m|
-        unless m =~ /^__/ || NON_DELEGATE_METHODS.include?(m.to_s)
-          delegate m, :to => :proxy_found
-        end
-      end
-
-      delegate :scopes, :with_scope, :scoped_methods, :to => :proxy_scope
-
-      def initialize(proxy_scope, options, &block)
-        options ||= {}
-        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new(&block) if block_given?
-        unless Scope === proxy_scope
-          @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
-        end
-        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
-      end
-
-      def reload
-        load_found; self
-      end
-
-      def first(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.first(*args)
-        else
-          find(:first, *args)
-        end
-      end
-
-      def last(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.last(*args)
-        else
-          find(:last, *args)
-        end
-      end
-
-      def size
-        @found ? @found.length : count
-      end
-
-      def empty?
-        @found ? @found.empty? : count.zero?
-      end
-
-      def respond_to?(method, include_private = false)
-        super || @proxy_scope.respond_to?(method, include_private)
-      end
-
-      def any?
-        if block_given?
-          proxy_found.any? { |*block_args| yield(*block_args) }
-        else
-          !empty?
-        end
-      end
-
-      protected
-      def proxy_found
-        @found || load_found
-      end
-
-      private
-      def method_missing(method, *args, &block)
-        if scopes.include?(method)
-          scopes[method].call(self, *args)
-        else
-          with_scope({:find => proxy_options, :create => proxy_options[:conditions].is_a?(Hash) ?  proxy_options[:conditions] : {}}, :reverse_merge) do
-            method = :new if method == :build
-            if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined)
-              with_scope current_scoped_methods_when_defined do
-                proxy_scope.send(method, *args, &block)
-              end
-            else
-              proxy_scope.send(method, *args, &block)
-            end
-          end
-        end
-      end
-
-      def load_found
-        @found = find(:all)
-      end
-    end
-  end
-end

data/spec/rails2_3/vendor/rails/vendor/rails/activerecord/pkg/activerecord-2.3.3/lib/active_record/nested_attributes.rb

@@ -1,329 +0,0 @@
-module ActiveRecord
-  module NestedAttributes #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.class_inheritable_accessor :reject_new_nested_attributes_procs, :instance_writer => false
-      base.reject_new_nested_attributes_procs = {}
-    end
-
-    # == Nested Attributes
-    #
-    # Nested attributes allow you to save attributes on associated records
-    # through the parent. By default nested attribute updating is turned off,
-    # you can enable it using the accepts_nested_attributes_for class method.
-    # When you enable nested attributes an attribute writer is defined on
-    # the model.
-    #
-    # The attribute writer is named after the association, which means that
-    # in the following example, two new methods are added to your model:
-    # <tt>author_attributes=(attributes)</tt> and
-    # <tt>pages_attributes=(attributes)</tt>.
-    #
-    #   class Book < ActiveRecord::Base
-    #     has_one :author
-    #     has_many :pages
-    #
-    #     accepts_nested_attributes_for :author, :pages
-    #   end
-    #
-    # Note that the <tt>:autosave</tt> option is automatically enabled on every
-    # association that accepts_nested_attributes_for is used for.
-    #
-    # === One-to-one
-    #
-    # Consider a Member model that has one Avatar:
-    #
-    #   class Member < ActiveRecord::Base
-    #     has_one :avatar
-    #     accepts_nested_attributes_for :avatar
-    #   end
-    #
-    # Enabling nested attributes on a one-to-one association allows you to
-    # create the member and avatar in one go:
-    #
-    #   params = { :member => { :name => 'Jack', :avatar_attributes => { :icon => 'smiling' } } }
-    #   member = Member.create(params)
-    #   member.avatar.id # => 2
-    #   member.avatar.icon # => 'smiling'
-    #
-    # It also allows you to update the avatar through the member:
-    #
-    #   params = { :member' => { :avatar_attributes => { :id => '2', :icon => 'sad' } } }
-    #   member.update_attributes params['member']
-    #   member.avatar.icon # => 'sad'
-    #
-    # By default you will only be able to set and update attributes on the
-    # associated model. If you want to destroy the associated model through the
-    # attributes hash, you have to enable it first using the
-    # <tt>:allow_destroy</tt> option.
-    #
-    #   class Member < ActiveRecord::Base
-    #     has_one :avatar
-    #     accepts_nested_attributes_for :avatar, :allow_destroy => true
-    #   end
-    #
-    # Now, when you add the <tt>_delete</tt> key to the attributes hash, with a
-    # value that evaluates to +true+, you will destroy the associated model:
-    #
-    #   member.avatar_attributes = { :id => '2', :_delete => '1' }
-    #   member.avatar.marked_for_destruction? # => true
-    #   member.save
-    #   member.avatar #=> nil
-    #
-    # Note that the model will _not_ be destroyed until the parent is saved.
-    #
-    # === One-to-many
-    #
-    # Consider a member that has a number of posts:
-    #
-    #   class Member < ActiveRecord::Base
-    #     has_many :posts
-    #     accepts_nested_attributes_for :posts
-    #   end
-    #
-    # You can now set or update attributes on an associated post model through
-    # the attribute hash.
-    #
-    # For each hash that does _not_ have an <tt>id</tt> key a new record will
-    # be instantiated, unless the hash also contains a <tt>_delete</tt> key
-    # that evaluates to +true+.
-    #
-    #   params = { :member => {
-    #     :name => 'joe', :posts_attributes => [
-    #       { :title => 'Kari, the awesome Ruby documentation browser!' },
-    #       { :title => 'The egalitarian assumption of the modern citizen' },
-    #       { :title => '', :_delete => '1' } # this will be ignored
-    #     ]
-    #   }}
-    #
-    #   member = Member.create(params['member'])
-    #   member.posts.length # => 2
-    #   member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!'
-    #   member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
-    #
-    # You may also set a :reject_if proc to silently ignore any new record
-    # hashes if they fail to pass your criteria. For example, the previous
-    # example could be rewritten as:
-    #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, :reject_if => proc { |attributes| attributes['title'].blank? }
-    #    end
-    #
-    #   params = { :member => {
-    #     :name => 'joe', :posts_attributes => [
-    #       { :title => 'Kari, the awesome Ruby documentation browser!' },
-    #       { :title => 'The egalitarian assumption of the modern citizen' },
-    #       { :title => '' } # this will be ignored because of the :reject_if proc
-    #     ]
-    #   }}
-    #
-    #   member = Member.create(params['member'])
-    #   member.posts.length # => 2
-    #   member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!'
-    #   member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
-    #
-    # If the hash contains an <tt>id</tt> key that matches an already
-    # associated record, the matching record will be modified:
-    #
-    #   member.attributes = {
-    #     :name => 'Joe',
-    #     :posts_attributes => [
-    #       { :id => 1, :title => '[UPDATED] An, as of yet, undisclosed awesome Ruby documentation browser!' },
-    #       { :id => 2, :title => '[UPDATED] other post' }
-    #     ]
-    #   }
-    #
-    #   member.posts.first.title # => '[UPDATED] An, as of yet, undisclosed awesome Ruby documentation browser!'
-    #   member.posts.second.title # => '[UPDATED] other post'
-    #
-    # By default the associated records are protected from being destroyed. If
-    # you want to destroy any of the associated records through the attributes
-    # hash, you have to enable it first using the <tt>:allow_destroy</tt>
-    # option. This will allow you to also use the <tt>_delete</tt> key to
-    # destroy existing records:
-    #
-    #   class Member < ActiveRecord::Base
-    #     has_many :posts
-    #     accepts_nested_attributes_for :posts, :allow_destroy => true
-    #   end
-    #
-    #   params = { :member => {
-    #     :posts_attributes => [{ :id => '2', :_delete => '1' }]
-    #   }}
-    #
-    #   member.attributes = params['member']
-    #   member.posts.detect { |p| p.id == 2 }.marked_for_destruction? # => true
-    #   member.posts.length #=> 2
-    #   member.save
-    #   member.posts.length # => 1
-    #
-    # === Saving
-    #
-    # All changes to models, including the destruction of those marked for
-    # destruction, are saved and destroyed automatically and atomically when
-    # the parent model is saved. This happens inside the transaction initiated
-    # by the parents save method. See ActiveRecord::AutosaveAssociation.
-    module ClassMethods
-      # Defines an attributes writer for the specified association(s). If you
-      # are using <tt>attr_protected</tt> or <tt>attr_accessible</tt>, then you
-      # will need to add the attribute writer to the allowed list.
-      #
-      # Supported options:
-      # [:allow_destroy]
-      #   If true, destroys any members from the attributes hash with a
-      #   <tt>_delete</tt> key and a value that evaluates to +true+
-      #   (eg. 1, '1', true, or 'true'). This option is off by default.
-      # [:reject_if]
-      #   Allows you to specify a Proc that checks whether a record should be
-      #   built for a certain attribute hash. The hash is passed to the Proc
-      #   and the Proc should return either +true+ or +false+. When no Proc
-      #   is specified a record will be built for all attribute hashes that
-      #   do not have a <tt>_delete</tt> that evaluates to true.
-      #
-      # Examples:
-      #   # creates avatar_attributes=
-      #   accepts_nested_attributes_for :avatar, :reject_if => proc { |attributes| attributes['name'].blank? }
-      #   # creates avatar_attributes= and posts_attributes=
-      #   accepts_nested_attributes_for :avatar, :posts, :allow_destroy => true
-      def accepts_nested_attributes_for(*attr_names)
-        options = { :allow_destroy => false }
-        options.update(attr_names.extract_options!)
-        options.assert_valid_keys(:allow_destroy, :reject_if)
-
-        attr_names.each do |association_name|
-          if reflection = reflect_on_association(association_name)
-            type = case reflection.macro
-            when :has_one, :belongs_to
-              :one_to_one
-            when :has_many, :has_and_belongs_to_many
-              :collection
-            end
-
-            reflection.options[:autosave] = true
-            self.reject_new_nested_attributes_procs[association_name.to_sym] = options[:reject_if]
-
-            # def pirate_attributes=(attributes)
-            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes, false)
-            # end
-            class_eval %{
-              def #{association_name}_attributes=(attributes)
-                assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes, #{options[:allow_destroy]})
-              end
-            }, __FILE__, __LINE__
-          else
-            raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
-          end
-        end
-      end
-    end
-
-    # Returns ActiveRecord::AutosaveAssociation::marked_for_destruction? It's
-    # used in conjunction with fields_for to build a form element for the
-    # destruction of this association.
-    #
-    # See ActionView::Helpers::FormHelper::fields_for for more info.
-    def _delete
-      marked_for_destruction?
-    end
-
-    private
-
-    # Attribute hash keys that should not be assigned as normal attributes.
-    # These hash keys are nested attributes implementation details.
-    UNASSIGNABLE_KEYS = %w{ id _delete }
-
-    # Assigns the given attributes to the association.
-    #
-    # If the given attributes include an <tt>:id</tt> that matches the existing
-    # record’s id, then the existing record will be modified. Otherwise a new
-    # record will be built.
-    #
-    # If the given attributes include a matching <tt>:id</tt> attribute _and_ a
-    # <tt>:_delete</tt> key set to a truthy value, then the existing record
-    # will be marked for destruction.
-    def assign_nested_attributes_for_one_to_one_association(association_name, attributes, allow_destroy)
-      attributes = attributes.stringify_keys
-
-      if attributes['id'].blank?
-        unless reject_new_record?(association_name, attributes)
-          send("build_#{association_name}", attributes.except(*UNASSIGNABLE_KEYS))
-        end
-      elsif (existing_record = send(association_name)) && existing_record.id.to_s == attributes['id'].to_s
-        assign_to_or_mark_for_destruction(existing_record, attributes, allow_destroy)
-      end
-    end
-
-    # Assigns the given attributes to the collection association.
-    #
-    # Hashes with an <tt>:id</tt> value matching an existing associated record
-    # will update that record. Hashes without an <tt>:id</tt> value will build
-    # a new record for the association. Hashes with a matching <tt>:id</tt>
-    # value and a <tt>:_delete</tt> key set to a truthy value will mark the
-    # matched record for destruction.
-    #
-    # For example:
-    #
-    #   assign_nested_attributes_for_collection_association(:people, {
-    #     '1' => { :id => '1', :name => 'Peter' },
-    #     '2' => { :name => 'John' },
-    #     '3' => { :id => '2', :_delete => true }
-    #   })
-    #
-    # Will update the name of the Person with ID 1, build a new associated
-    # person with the name `John', and mark the associatied Person with ID 2
-    # for destruction.
-    #
-    # Also accepts an Array of attribute hashes:
-    #
-    #   assign_nested_attributes_for_collection_association(:people, [
-    #     { :id => '1', :name => 'Peter' },
-    #     { :name => 'John' },
-    #     { :id => '2', :_delete => true }
-    #   ])
-    def assign_nested_attributes_for_collection_association(association_name, attributes_collection, allow_destroy)
-      unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-        raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
-      end
-
-      if attributes_collection.is_a? Hash
-        attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
-      end
-
-      attributes_collection.each do |attributes|
-        attributes = attributes.stringify_keys
-
-        if attributes['id'].blank?
-          unless reject_new_record?(association_name, attributes)
-            send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
-          end
-        elsif existing_record = send(association_name).detect { |record| record.id.to_s == attributes['id'].to_s }
-          assign_to_or_mark_for_destruction(existing_record, attributes, allow_destroy)
-        end
-      end
-    end
-
-    # Updates a record with the +attributes+ or marks it for destruction if
-    # +allow_destroy+ is +true+ and has_delete_flag? returns +true+.
-    def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
-      if has_delete_flag?(attributes) && allow_destroy
-        record.mark_for_destruction
-      else
-        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
-      end
-    end
-
-    # Determines if a hash contains a truthy _delete key.
-    def has_delete_flag?(hash)
-      ConnectionAdapters::Column.value_to_boolean hash['_delete']
-    end
-
-    # Determines if a new record should be build by checking for
-    # has_delete_flag? or if a <tt>:reject_if</tt> proc exists for this
-    # association and evaluates to +true+.
-    def reject_new_record?(association_name, attributes)
-      has_delete_flag?(attributes) ||
-        self.class.reject_new_nested_attributes_procs[association_name].try(:call, attributes)
-    end
-  end
-end