activerecord 1.0.0 → 4.0.0

data/lib/active_record/attribute_assignment.rb

@@ -0,0 +1,201 @@
+
+module ActiveRecord
+  module AttributeAssignment
+    extend ActiveSupport::Concern
+    include ActiveModel::DeprecatedMassAssignmentSecurity
+    include ActiveModel::ForbiddenAttributesProtection
+
+    # Allows you to set all the attributes by passing in a hash of attributes with
+    # keys matching the attribute names (which again matches the column names).
+    #
+    # If the passed hash responds to <tt>permitted?</tt> method and the return value
+    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # exception is raised.
+    def assign_attributes(new_attributes)
+      return if new_attributes.blank?
+
+      attributes                  = new_attributes.stringify_keys
+      multi_parameter_attributes  = []
+      nested_parameter_attributes = []
+
+      attributes = sanitize_for_mass_assignment(attributes)
+
+      attributes.each do |k, v|
+        if k.include?("(")
+          multi_parameter_attributes << [ k, v ]
+        elsif v.is_a?(Hash)
+          nested_parameter_attributes << [ k, v ]
+        else
+          _assign_attribute(k, v)
+        end
+      end
+
+      assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
+      assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
+    end
+
+    alias attributes= assign_attributes
+
+    private
+
+    def _assign_attribute(k, v)
+      public_send("#{k}=", v)
+    rescue NoMethodError
+      if respond_to?("#{k}=")
+        raise
+      else
+        raise UnknownAttributeError, "unknown attribute: #{k}"
+      end
+    end
+
+    # Assign any deferred nested attributes after the base attributes have been set.
+    def assign_nested_parameter_attributes(pairs)
+      pairs.each { |k, v| _assign_attribute(k, v) }
+    end
+
+    # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
+    # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
+    # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
+    # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
+    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum and
+    # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
+    def assign_multiparameter_attributes(pairs)
+      execute_callstack_for_multiparameter_attributes(
+        extract_callstack_for_multiparameter_attributes(pairs)
+      )
+    end
+
+    def execute_callstack_for_multiparameter_attributes(callstack)
+      errors = []
+      callstack.each do |name, values_with_empty_parameters|
+        begin
+          send("#{name}=", MultiparameterAttribute.new(self, name, values_with_empty_parameters).read_value)
+        rescue => ex
+          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
+        end
+      end
+      unless errors.empty?
+        error_descriptions = errors.map { |ex| ex.message }.join(",")
+        raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
+      end
+    end
+
+    def extract_callstack_for_multiparameter_attributes(pairs)
+      attributes = {}
+
+      pairs.each do |(multiparameter_name, value)|
+        attribute_name = multiparameter_name.split("(").first
+        attributes[attribute_name] ||= {}
+
+        parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+        attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+      end
+
+      attributes
+    end
+
+    def type_cast_attribute_value(multiparameter_name, value)
+      multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+    end
+
+    def find_parameter_position(multiparameter_name)
+      multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
+    end
+
+    class MultiparameterAttribute #:nodoc:
+      attr_reader :object, :name, :values, :column
+
+      def initialize(object, name, values)
+        @object = object
+        @name   = name
+        @values = values
+      end
+
+      def read_value
+        return if values.values.compact.empty?
+
+        @column = object.class.reflect_on_aggregation(name.to_sym) || object.column_for_attribute(name)
+        klass   = column.klass
+
+        if klass == Time
+          read_time
+        elsif klass == Date
+          read_date
+        else
+          read_other(klass)
+        end
+      end
+
+      private
+
+      def instantiate_time_object(set_values)
+        if object.class.send(:create_time_zone_conversion_attribute?, name, column)
+          Time.zone.local(*set_values)
+        else
+          Time.send(object.class.default_timezone, *set_values)
+        end
+      end
+
+      def read_time
+        # If column is a :time (and not :date or :timestamp) there is no need to validate if
+        # there are year/month/day fields
+        if column.type == :time
+          # if the column is a time set the values to their defaults as January 1, 1970, but only if they're nil
+          { 1 => 1970, 2 => 1, 3 => 1 }.each do |key,value|
+            values[key] ||= value
+          end
+        else
+          # else column is a timestamp, so if Date bits were not provided, error
+          validate_required_parameters!([1,2,3])
+
+          # If Date bits were provided but blank, then return nil
+          return if blank_date_parameter?
+        end
+
+        max_position = extract_max_param(6)
+        set_values   = values.values_at(*(1..max_position))
+        # If Time bits are not there, then default to 0
+        (3..5).each { |i| set_values[i] = set_values[i].presence || 0 }
+        instantiate_time_object(set_values)
+      end
+
+      def read_date
+        return if blank_date_parameter?
+        set_values = values.values_at(1,2,3)
+        begin
+          Date.new(*set_values)
+        rescue ArgumentError # if Date.new raises an exception on an invalid date
+          instantiate_time_object(set_values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
+        end
+      end
+
+      def read_other(klass)
+        max_position = extract_max_param
+        positions    = (1..max_position)
+        validate_required_parameters!(positions)
+
+        set_values = values.values_at(*positions)
+        klass.new(*set_values)
+      end
+
+      # Checks whether some blank date parameter exists. Note that this is different
+      # than the validate_required_parameters! method, since it just checks for blank
+      # positions instead of missing ones, and does not raise in case one blank position
+      # exists. The caller is responsible to handle the case of this returning true.
+      def blank_date_parameter?
+        (1..3).any? { |position| values[position].blank? }
+      end
+
+      # If some position is not provided, it errors out a missing parameter exception.
+      def validate_required_parameters!(positions)
+        if missing_parameter = positions.detect { |position| !values.key?(position) }
+          raise ArgumentError.new("Missing Parameter - #{name}(#{missing_parameter})")
+        end
+      end
+
+      def extract_max_param(upper_cap = 100)
+        [values.keys.max, upper_cap].min
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  module AttributeMethods
+    # = Active Record Attribute Methods Before Type Cast
+    #
+    # <tt>ActiveRecord::AttributeMethods::BeforeTypeCast</tt> provides a way to
+    # read the value of the attributes before typecasting and deserialization.
+    #
+    #   class Task < ActiveRecord::Base
+    #   end
+    #
+    #   task = Task.new(id: '1', completed_on: '2012-10-21')
+    #   task.id           # => 1
+    #   task.completed_on # => Sun, 21 Oct 2012
+    #
+    #   task.attributes_before_type_cast
+    #   # => {"id"=>"1", "completed_on"=>"2012-10-21", ... }
+    #   task.read_attribute_before_type_cast('id')           # => "1"
+    #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+    #
+    # In addition to #read_attribute_before_type_cast and #attributes_before_type_cast,
+    # it declares a method for all attributes with the <tt>*_before_type_cast</tt>
+    # suffix.
+    #
+    #   task.id_before_type_cast           # => "1"
+    #   task.completed_on_before_type_cast # => "2012-10-21"
+    module BeforeTypeCast
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "_before_type_cast"
+      end
+
+      # Returns the value of the attribute identified by +attr_name+ before
+      # typecasting and deserialization.
+      #
+      #   class Task < ActiveRecord::Base
+      #   end
+      #
+      #   task = Task.new(id: '1', completed_on: '2012-10-21')
+      #   task.read_attribute('id')                            # => 1
+      #   task.read_attribute_before_type_cast('id')           # => '1'
+      #   task.read_attribute('completed_on')                  # => Sun, 21 Oct 2012
+      #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+      def read_attribute_before_type_cast(attr_name)
+        @attributes[attr_name]
+      end
+
+      # Returns a hash of attributes before typecasting and deserialization.
+      #
+      #   class Task < ActiveRecord::Base
+      #   end
+      #
+      #   task = Task.new(title: nil, is_done: true, completed_on: '2012-10-21')
+      #   task.attributes
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>Sun, 21 Oct 2012, "created_at"=>nil, "updated_at"=>nil}
+      #   task.attributes_before_type_cast
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}
+      def attributes_before_type_cast
+        @attributes
+      end
+
+      private
+
+      # Handle *_before_type_cast for method_missing.
+      def attribute_before_type_cast(attribute_name)
+        read_attribute_before_type_cast(attribute_name)
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/dirty.rb

@@ -0,0 +1,118 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+module ActiveRecord
+  module AttributeMethods
+    module Dirty # :nodoc:
+      extend ActiveSupport::Concern
+
+      include ActiveModel::Dirty
+
+      included do
+        if self < ::ActiveRecord::Timestamp
+          raise "You cannot include Dirty after Timestamp"
+        end
+
+        class_attribute :partial_writes, instance_writer: false
+        self.partial_writes = true
+
+        def self.partial_updates=(v); self.partial_writes = v; end
+        def self.partial_updates?; partial_writes?; end
+        def self.partial_updates; partial_writes; end
+
+        ActiveSupport::Deprecation.deprecate_methods(
+          singleton_class,
+          :partial_updates= => :partial_writes=,
+          :partial_updates? => :partial_writes?,
+          :partial_updates  => :partial_writes
+        )
+      end
+
+      # Attempts to +save+ the record and clears changed attributes if successful.
+      def save(*)
+        if status = super
+          @previously_changed = changes
+          @changed_attributes.clear
+        end
+        status
+      end
+
+      # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
+      def save!(*)
+        super.tap do
+          @previously_changed = changes
+          @changed_attributes.clear
+        end
+      end
+
+      # <tt>reload</tt> the record and clears changed attributes.
+      def reload(*)
+        super.tap do
+          @previously_changed.clear
+          @changed_attributes.clear
+        end
+      end
+
+    private
+      # Wrap write_attribute to remember original attribute value.
+      def write_attribute(attr, value)
+        attr = attr.to_s
+
+        # The attribute already has an unsaved change.
+        if attribute_changed?(attr)
+          old = @changed_attributes[attr]
+          @changed_attributes.delete(attr) unless _field_changed?(attr, old, value)
+        else
+          old = clone_attribute_value(:read_attribute, attr)
+          @changed_attributes[attr] = old if _field_changed?(attr, old, value)
+        end
+
+        # Carry on.
+        super(attr, value)
+      end
+
+      def update_record(*)
+        partial_writes? ? super(keys_for_partial_write) : super
+      end
+
+      def create_record(*)
+        partial_writes? ? super(keys_for_partial_write) : super
+      end
+
+      # Serialized attributes should always be written in case they've been
+      # changed in place.
+      def keys_for_partial_write
+        changed | (attributes.keys & self.class.serialized_attributes.keys)
+      end
+
+      def _field_changed?(attr, old, value)
+        if column = column_for_attribute(attr)
+          if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
+                                changes_from_zero_to_string?(old, value))
+            value = nil
+          else
+            value = column.type_cast(value)
+          end
+        end
+
+        old != value
+      end
+
+      def changes_from_nil_to_empty_string?(column, old, value)
+        # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
+        # Hence we don't record it as a change if the value changes from nil to ''.
+        # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+        # be typecast back to 0 (''.to_i => 0)
+        column.null && (old.nil? || old == 0) && value.blank?
+      end
+
+      def changes_from_zero_to_string?(old, value)
+        # For columns with old 0 and value non-empty string
+        old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
+      end
+
+      def non_zero?(value)
+        value !~ /\A0+(\.0+)?\z/
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -0,0 +1,122 @@
+require 'set'
+
+module ActiveRecord
+  module AttributeMethods
+    module PrimaryKey
+      extend ActiveSupport::Concern
+
+      # Returns this record's primary key value wrapped in an Array if one is
+      # available.
+      def to_key
+        sync_with_transaction_state
+        key = self.id
+        [key] if key
+      end
+
+      # Returns the primary key value.
+      def id
+        sync_with_transaction_state
+        read_attribute(self.class.primary_key)
+      end
+
+      # Sets the primary key value.
+      def id=(value)
+        sync_with_transaction_state
+        write_attribute(self.class.primary_key, value) if self.class.primary_key
+      end
+
+      # Queries the primary key value.
+      def id?
+        sync_with_transaction_state
+        query_attribute(self.class.primary_key)
+      end
+
+      # Returns the primary key value before type cast.
+      def id_before_type_cast
+        sync_with_transaction_state
+        read_attribute_before_type_cast(self.class.primary_key)
+      end
+
+      protected
+
+      def attribute_method?(attr_name)
+        attr_name == 'id' || super
+      end
+
+      module ClassMethods
+        def define_method_attribute(attr_name)
+          super
+
+          if attr_name == primary_key && attr_name != 'id'
+            generated_attribute_methods.send(:alias_method, :id, primary_key)
+          end
+        end
+
+        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast).to_set
+
+        def dangerous_attribute_method?(method_name)
+          super && !ID_ATTRIBUTE_METHODS.include?(method_name)
+        end
+
+        # Defines the primary key field -- can be overridden in subclasses.
+        # Overwriting will negate any effect of the +primary_key_prefix_type+
+        # setting, though.
+        def primary_key
+          @primary_key = reset_primary_key unless defined? @primary_key
+          @primary_key
+        end
+
+        # Returns a quoted version of the primary key name, used to construct
+        # SQL statements.
+        def quoted_primary_key
+          @quoted_primary_key ||= connection.quote_column_name(primary_key)
+        end
+
+        def reset_primary_key #:nodoc:
+          if self == base_class
+            self.primary_key = get_primary_key(base_class.name)
+          else
+            self.primary_key = base_class.primary_key
+          end
+        end
+
+        def get_primary_key(base_name) #:nodoc:
+          return 'id' if base_name.blank?
+
+          case primary_key_prefix_type
+          when :table_name
+            base_name.foreign_key(false)
+          when :table_name_with_underscore
+            base_name.foreign_key
+          else
+            if ActiveRecord::Base != self && table_exists?
+              connection.schema_cache.primary_keys(table_name)
+            else
+              'id'
+            end
+          end
+        end
+
+        # Sets the name of the primary key column.
+        #
+        #   class Project < ActiveRecord::Base
+        #     self.primary_key = 'sysid'
+        #   end
+        #
+        # You can also define the +primary_key+ method yourself:
+        #
+        #   class Project < ActiveRecord::Base
+        #     def self.primary_key
+        #       'foo_' + super
+        #     end
+        #   end
+        #
+        #   Project.primary_key # => "foo_id"
+        def primary_key=(value)
+          @primary_key        = value && value.to_s
+          @quoted_primary_key = nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/query.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module AttributeMethods
+    module Query
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "?"
+      end
+
+      def query_attribute(attr_name)
+        value = read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+
+        case value
+        when true        then true
+        when false, nil  then false
+        else
+          column = self.class.columns_hash[attr_name]
+          if column.nil?
+            if Numeric === value || value !~ /[^0-9]/
+              !value.to_i.zero?
+            else
+              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif column.number?
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+
+      private
+        # Handle *? for method_missing.
+        def attribute?(attribute_name)
+          query_attribute(attribute_name)
+        end
+    end
+  end
+end

data/lib/active_record/attribute_methods/read.rb

@@ -0,0 +1,107 @@
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
+
+      included do
+        class_attribute :attribute_types_cached_by_default, instance_writer: false
+        self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+      end
+
+      module ClassMethods
+        # +cache_attributes+ allows you to declare which converted attribute
+        # values should be cached. Usually caching only pays off for attributes
+        # with expensive conversion methods, like time related columns (e.g.
+        # +created_at+, +updated_at+).
+        def cache_attributes(*attribute_names)
+          cached_attributes.merge attribute_names.map { |attr| attr.to_s }
+        end
+
+        # Returns the attributes which are cached. By default time related columns
+        # with datatype <tt>:datetime, :timestamp, :time, :date</tt> are cached.
+        def cached_attributes
+          @cached_attributes ||= columns.select { |c| cacheable_column?(c) }.map { |col| col.name }.to_set
+        end
+
+        # Returns +true+ if the provided attribute is being cached.
+        def cache_attribute?(attr_name)
+          cached_attributes.include?(attr_name)
+        end
+
+        protected
+
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch and
+        # uses more memory (because it creates a closure).
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes_cache in read_attribute.
+        def define_method_attribute(name)
+          safe_name = name.unpack('h*').first
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}
+              read_attribute(AttrNames::ATTR_#{safe_name}) { |n| missing_attribute(n, caller) }
+            end
+            alias_method #{name.inspect}, :__temp__#{safe_name}
+            undef_method :__temp__#{safe_name}
+          STR
+        end
+
+        private
+
+        def cacheable_column?(column)
+          if attribute_types_cached_by_default == ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+            ! serialized_attributes.include? column.name
+          else
+            attribute_types_cached_by_default.include?(column.type)
+          end
+        end
+      end
+
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # it has been typecast (for example, "2004-12-12" in a data column is cast
+      # to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(attr_name)
+        # If it's cached, just return it
+        # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
+        name = attr_name.to_s
+        @attributes_cache[name] || @attributes_cache.fetch(name) {
+          column = @columns_hash.fetch(name) {
+            return @attributes.fetch(name) {
+              if name == 'id' && self.class.primary_key != name
+                read_attribute(self.class.primary_key)
+              end
+            }
+          }
+
+          value = @attributes.fetch(name) {
+            return block_given? ? yield(name) : nil
+          }
+
+          if self.class.cache_attribute?(name)
+            @attributes_cache[name] = column.type_cast(value)
+          else
+            column.type_cast value
+          end
+        }
+      end
+
+      private
+
+      def attribute(attribute_name)
+        read_attribute(attribute_name)
+      end
+    end
+  end
+end