activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,4 +1,4 @@
-require 'set'
+require "set"
 
 module ActiveRecord
   module AttributeMethods
@@ -9,7 +9,7 @@ module ActiveRecord
       # available.
       def to_key
         sync_with_transaction_state
-        key = self.id
+        key = id
         [key] if key
       end
 
@@ -45,97 +45,102 @@ module ActiveRecord
         attribute_was(self.class.primary_key)
       end
 
-      protected
-
-      def attribute_method?(attr_name)
-        attr_name == 'id' || super
+      def id_in_database
+        sync_with_transaction_state
+        attribute_in_database(self.class.primary_key)
       end
 
-      module ClassMethods
-        def define_method_attribute(attr_name)
-          super
+      private
 
-          if attr_name == primary_key && attr_name != 'id'
-            generated_attribute_methods.send(:alias_method, :id, primary_key)
-          end
+        def attribute_method?(attr_name)
+          attr_name == "id" || super
         end
 
-        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
+        module ClassMethods
+          def define_method_attribute(attr_name)
+            super
 
-        def dangerous_attribute_method?(method_name)
-          super && !ID_ATTRIBUTE_METHODS.include?(method_name)
-        end
+            if attr_name == primary_key && attr_name != "id"
+              generated_attribute_methods.send(:alias_method, :id, primary_key)
+            end
+          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
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
 
-        # 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 dangerous_attribute_method?(method_name)
+            super && !ID_ATTRIBUTE_METHODS.include?(method_name)
+          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
+          # 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
-        end
 
-        def get_primary_key(base_name) #:nodoc:
-          if base_name && primary_key_prefix_type == :table_name
-            base_name.foreign_key(false)
-          elsif base_name && primary_key_prefix_type == :table_name_with_underscore
-            base_name.foreign_key
-          else
-            if ActiveRecord::Base != self && table_exists?
-              pk = connection.schema_cache.primary_keys(table_name)
-              suppress_composite_primary_key(pk)
+          # 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
-              'id'
+              self.primary_key = base_class.primary_key
             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
-          @attributes_builder = nil
-        end
+          def get_primary_key(base_name) #:nodoc:
+            if base_name && primary_key_prefix_type == :table_name
+              base_name.foreign_key(false)
+            elsif base_name && primary_key_prefix_type == :table_name_with_underscore
+              base_name.foreign_key
+            else
+              if ActiveRecord::Base != self && table_exists?
+                pk = connection.schema_cache.primary_keys(table_name)
+                suppress_composite_primary_key(pk)
+              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
+            @attributes_builder = nil
+          end
 
-        private
+          private
 
-        def suppress_composite_primary_key(pk)
-          return pk unless pk.is_a?(Array)
+            def suppress_composite_primary_key(pk)
+              return pk unless pk.is_a?(Array)
 
-          warn <<-WARNING.strip_heredoc
-            WARNING: Active Record does not support composite primary key.
+              warn <<-WARNING.strip_heredoc
+                WARNING: Active Record does not support composite primary key.
 
-            #{table_name} has composite primary key. Composite primary key is ignored.
-          WARNING
+                #{table_name} has composite primary key. Composite primary key is ignored.
+              WARNING
+            end
         end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/read.rb

@@ -4,51 +4,56 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       module ClassMethods
-        protected
+        private
 
-        # We want to generate the methods via module_eval rather than
-        # define_method, because define_method is slower on dispatch.
-        # Evaluating many similar methods may use more memory as the instruction
-        # sequences are duplicated and cached (in MRI).  define_method may
-        # be slower on dispatch, but if you're careful about the closure
-        # created, then define_method will consume much less memory.
-        #
-        # 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 in read_attribute.
-        def define_method_attribute(name)
-          safe_name = name.unpack('h*'.freeze).first
-          temp_method = "__temp__#{safe_name}"
+          # We want to generate the methods via module_eval rather than
+          # define_method, because define_method is slower on dispatch.
+          # Evaluating many similar methods may use more memory as the instruction
+          # sequences are duplicated and cached (in MRI).  define_method may
+          # be slower on dispatch, but if you're careful about the closure
+          # created, then define_method will consume much less memory.
+          #
+          # 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 in read_attribute.
+          def define_method_attribute(name)
+            safe_name = name.unpack("h*".freeze).first
+            temp_method = "__temp__#{safe_name}"
 
-          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-            def #{temp_method}
-              name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-              _read_attribute(name) { |n| missing_attribute(n, caller) }
-            end
-          STR
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def #{temp_method}
+                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                _read_attribute(name) { |n| missing_attribute(n, caller) }
+              end
+            STR
 
-          generated_attribute_methods.module_eval do
-            alias_method name, temp_method
-            undef_method temp_method
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
+            end
           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 date column is cast
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
-        name = attr_name.to_s
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+
         name = self.class.primary_key if name == "id".freeze && self.class.primary_key
         _read_attribute(name, &block)
       end
@@ -69,7 +74,6 @@ module ActiveRecord
 
       alias :attribute :_read_attribute
       private :attribute
-
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -26,7 +26,7 @@ module ActiveRecord
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
         #   or a class name that the object type should be equal to.
         #
         # ==== Example
@@ -50,12 +50,12 @@ module ActiveRecord
           # to ensure special objects (e.g. Active Record models) are dumped correctly
           # using the #as_json hook.
           coder = if class_name_or_coder == ::JSON
-                    Coders::JSON
-                  elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
-                    class_name_or_coder
-                  else
-                    Coders::YAMLColumn.new(class_name_or_coder)
-                  end
+            Coders::JSON
+          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+            class_name_or_coder
+          else
+            Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+          end
 
           decorate_attribute_type(attr_name, :serialize) do |type|
             Type::Serialized.new(type, coder)

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/strip'
-
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
@@ -26,31 +24,31 @@ module ActiveRecord
 
         private
 
-        def convert_time_to_time_zone(value)
-          return if value.nil?
+          def convert_time_to_time_zone(value)
+            return if value.nil?
 
-          if value.acts_like?(:time)
-            value.in_time_zone
-          elsif value.is_a?(::Float)
-            value
-          else
-            map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+            if value.acts_like?(:time)
+              value.in_time_zone
+            elsif value.is_a?(::Float)
+              value
+            else
+              map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+            end
           end
-        end
 
-        def set_time_zone_without_conversion(value)
-          ::Time.zone.local_to_utc(value).in_time_zone if value
-        end
+          def set_time_zone_without_conversion(value)
+            ::Time.zone.local_to_utc(value).try(:in_time_zone) if value
+          end
 
-        def map_avoiding_infinite_recursion(value)
-          map(value) do |v|
-            if value.equal?(v)
-              nil
-            else
-              yield(v)
+          def map_avoiding_infinite_recursion(value)
+            map(value) do |v|
+              if value.equal?(v)
+                nil
+              else
+                yield(v)
+              end
             end
           end
-        end
       end
 
       extend ActiveSupport::Concern
@@ -63,53 +61,32 @@ module ActiveRecord
         self.skip_time_zone_conversion_for_attributes = []
 
         class_attribute :time_zone_aware_types, instance_writer: false
-        self.time_zone_aware_types = [:datetime, :not_explicitly_configured]
+        self.time_zone_aware_types = [:datetime, :time]
       end
 
       module ClassMethods
         private
 
-        def inherited(subclass)
-          # We need to apply this decorator here, rather than on module inclusion. The closure
-          # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-          # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
-          # `skip_time_zone_conversion_for_attributes` would not be picked up.
-          subclass.class_eval do
-            matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
-            decorate_matching_attribute_types(matcher, :_time_zone_conversion) do |type|
-              TimeZoneConverter.new(type)
+          def inherited(subclass)
+            super
+            # We need to apply this decorator here, rather than on module inclusion. The closure
+            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
+            # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
+            # `skip_time_zone_conversion_for_attributes` would not be picked up.
+            subclass.class_eval do
+              matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
+              decorate_matching_attribute_types(matcher, :_time_zone_conversion) do |type|
+                TimeZoneConverter.new(type)
+              end
             end
           end
-          super
-        end
-
-        def create_time_zone_conversion_attribute?(name, cast_type)
-          enabled_for_column = time_zone_aware_attributes &&
-            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym)
-          result = enabled_for_column &&
-            time_zone_aware_types.include?(cast_type.type)
-
-          if enabled_for_column &&
-            !result &&
-            cast_type.type == :time &&
-            time_zone_aware_types.include?(:not_explicitly_configured)
-            ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
-              Time columns will become time zone aware in Rails 5.1. This
-              still causes `String`s to be parsed as if they were in `Time.zone`,
-              and `Time`s to be converted to `Time.zone`.
 
-              To keep the old behavior, you must add the following to your initializer:
+          def create_time_zone_conversion_attribute?(name, cast_type)
+            enabled_for_column = time_zone_aware_attributes &&
+              !skip_time_zone_conversion_for_attributes.include?(name.to_sym)
 
-                  config.active_record.time_zone_aware_types = [:datetime]
-
-              To use the new behavior, add the following:
-
-                  config.active_record.time_zone_aware_types = [:datetime, :time]
-            MESSAGE
+            enabled_for_column && time_zone_aware_types.include?(cast_type.type)
           end
-
-          result
-        end
       end
     end
   end

data/lib/active_record/attribute_methods/write.rb

@@ -8,28 +8,34 @@ module ActiveRecord
       end
 
       module ClassMethods
-        protected
-
-        def define_method_attribute=(name)
-          safe_name = name.unpack('h*'.freeze).first
-          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-            def __temp__#{safe_name}=(value)
-              name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-              write_attribute(name, value)
-            end
-            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-            undef_method :__temp__#{safe_name}=
-          STR
-        end
+        private
+
+          def define_method_attribute=(name)
+            safe_name = name.unpack("h*".freeze).first
+            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def __temp__#{safe_name}=(value)
+                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                write_attribute(name, value)
+              end
+              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+              undef_method :__temp__#{safe_name}=
+            STR
+          end
       end
 
       # Updates the attribute identified by <tt>attr_name</tt> with the
       # specified +value+. Empty strings for Integer and Float columns are
       # turned into +nil+.
       def write_attribute(attr_name, value)
-        write_attribute_with_type_cast(attr_name, value, true)
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+
+        write_attribute_with_type_cast(name, value, true)
       end
 
       def raw_write_attribute(attr_name, value) # :nodoc:
@@ -37,23 +43,23 @@ module ActiveRecord
       end
 
       private
-      # Handle *= for method_missing.
-      def attribute=(attribute_name, value)
-        write_attribute(attribute_name, value)
-      end
+        # Handle *= for method_missing.
+        def attribute=(attribute_name, value)
+          write_attribute(attribute_name, value)
+        end
 
-      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
-        attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
+        def write_attribute_with_type_cast(attr_name, value, should_type_cast)
+          attr_name = attr_name.to_s
+          attr_name = self.class.primary_key if attr_name == "id" && self.class.primary_key
 
-        if should_type_cast
-          @attributes.write_from_user(attr_name, value)
-        else
-          @attributes.write_cast_value(attr_name, value)
-        end
+          if should_type_cast
+            @attributes.write_from_user(attr_name, value)
+          else
+            @attributes.write_cast_value(attr_name, value)
+          end
 
-        value
-      end
+          value
+        end
     end
   end
 end