activemodel 5.0.7.2 → 5.1.0.beta1

data/lib/active_model/type/helpers/mutable.rb

@@ -1,7 +1,7 @@
 module ActiveModel
   module Type
-    module Helpers
-      module Mutable # :nodoc:
+    module Helpers # :nodoc: all
+      module Mutable
         def cast(value)
           deserialize(serialize(value))
         end

data/lib/active_model/type/helpers/numeric.rb

@@ -1,14 +1,15 @@
 module ActiveModel
   module Type
-    module Helpers
-      module Numeric # :nodoc:
+    module Helpers # :nodoc: all
+      module Numeric
         def cast(value)
-          value = case value
-                  when true then 1
-                  when false then 0
-                  when ::String then value.presence
-                  else value
-                  end
+          value = \
+            case value
+            when true then 1
+            when false then 0
+            when ::String then value.presence
+            else value
+            end
           super(value)
         end
 
@@ -18,16 +19,16 @@ module ActiveModel
 
         private
 
-        def number_to_non_number?(old_value, new_value_before_type_cast)
-          old_value != nil && non_numeric_string?(new_value_before_type_cast)
-        end
+          def number_to_non_number?(old_value, new_value_before_type_cast)
+            old_value != nil && non_numeric_string?(new_value_before_type_cast)
+          end
 
-        def non_numeric_string?(value)
-          # 'wibble'.to_i will give zero, we want to make sure
-          # that we aren't marking int zero to string zero as
-          # changed.
-          value.to_s !~ /\A-?\d+\.?\d*\z/
-        end
+          def non_numeric_string?(value)
+            # 'wibble'.to_i will give zero, we want to make sure
+            # that we aren't marking int zero to string zero as
+            # changed.
+            value.to_s !~ /\A-?\d+\.?\d*\z/
+          end
       end
     end
   end

data/lib/active_model/type/helpers/time_value.rb

@@ -2,8 +2,8 @@ require "active_support/core_ext/time/zones"
 
 module ActiveModel
   module Type
-    module Helpers
-      module TimeValue # :nodoc:
+    module Helpers # :nodoc: all
+      module TimeValue
         def serialize(value)
           value = apply_seconds_precision(value)
 
@@ -19,7 +19,7 @@ module ActiveModel
         end
 
         def is_utc?
-          ::Time.zone_default.nil? || ::Time.zone_default =~ 'UTC'
+          ::Time.zone_default.nil? || ::Time.zone_default =~ "UTC"
         end
 
         def default_timezone
@@ -33,8 +33,8 @@ module ActiveModel
         def apply_seconds_precision(value)
           return value unless precision && value.respond_to?(:usec)
           number_of_insignificant_digits = 6 - precision
-          round_power = 10 ** number_of_insignificant_digits
-          value.change(usec: value.usec / round_power * round_power)
+          round_power = 10**number_of_insignificant_digits
+          value.change(usec: value.usec - value.usec % round_power)
         end
 
         def type_cast_for_schema(value)
@@ -47,30 +47,30 @@ module ActiveModel
 
         private
 
-        def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
-          # Treat 0000-00-00 00:00:00 as nil.
-          return if year.nil? || (year == 0 && mon == 0 && mday == 0)
+          def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
+            # Treat 0000-00-00 00:00:00 as nil.
+            return if year.nil? || (year == 0 && mon == 0 && mday == 0)
 
-          if offset
-            time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
-            return unless time
+            if offset
+              time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+              return unless time
 
-            time -= offset
-            is_utc? ? time : time.getlocal
-          else
-            ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+              time -= offset
+              is_utc? ? time : time.getlocal
+            else
+              ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+            end
           end
-        end
 
-        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+          ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
 
-        # Doesn't handle time zones.
-        def fast_string_to_time(string)
-          if string =~ ISO_DATETIME
-            microsec = ($7.to_r * 1_000_000).to_i
-            new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+          # Doesn't handle time zones.
+          def fast_string_to_time(string)
+            if string =~ ISO_DATETIME
+              microsec = ($7.to_r * 1_000_000).to_i
+              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+            end
           end
-        end
       end
     end
   end

data/lib/active_model/type/immutable_string.rb

@@ -16,14 +16,15 @@ module ActiveModel
 
       private
 
-      def cast_value(value)
-        result = case value
-                 when true then "t"
-                 when false then "f"
-                 else value.to_s
-                 end
-        result.freeze
-      end
+        def cast_value(value)
+          result = \
+            case value
+            when true then "t"
+            when false then "f"
+            else value.to_s
+            end
+          result.freeze
+        end
     end
   end
 end

data/lib/active_model/type/integer.rb

@@ -29,38 +29,40 @@ module ActiveModel
         result
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :range
+        attr_reader :range
 
       private
 
-      def cast_value(value)
-        case value
-        when true then 1
-        when false then 0
-        else
-          value.to_i rescue nil
+        def cast_value(value)
+          case value
+          when true then 1
+          when false then 0
+          else
+            value.to_i rescue nil
+          end
         end
-      end
 
-      def ensure_in_range(value)
-        unless range.cover?(value)
-          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit}"
+        def ensure_in_range(value)
+          unless range.cover?(value)
+            raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+          end
         end
-      end
 
-      def max_value
-        1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
-      end
+        def max_value
+          1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
+        end
 
-      def min_value
-        -max_value
-      end
+        def min_value
+          -max_value
+        end
 
-      def _limit
-        self.limit || DEFAULT_LIMIT
-      end
+        def _limit
+          limit || DEFAULT_LIMIT
+        end
     end
   end
 end

data/lib/active_model/type/registry.rb

@@ -21,19 +21,21 @@ module ActiveModel
         end
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :registrations
+        attr_reader :registrations
 
       private
 
-      def registration_klass
-        Registration
-      end
+        def registration_klass
+          Registration
+        end
 
-      def find_registration(symbol, *args)
-        registrations.find { |r| r.matches?(symbol, *args) }
-      end
+        def find_registration(symbol, *args)
+          registrations.find { |r| r.matches?(symbol, *args) }
+        end
     end
 
     class Registration
@@ -55,9 +57,11 @@ module ActiveModel
         type_name == name
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :name, :block
+        attr_reader :name, :block
     end
   end
   # :startdoc:

data/lib/active_model/type/string.rb

@@ -12,12 +12,7 @@ module ActiveModel
       private
 
         def cast_value(value)
-          case value
-          when ::String then ::String.new(value)
-          when true then "t".freeze
-          when false then "f".freeze
-          else value.to_s
-          end
+          ::String.new(super)
         end
     end
   end

data/lib/active_model/type/time.rb

@@ -25,18 +25,22 @@ module ActiveModel
 
       private
 
-      def cast_value(value)
-        return apply_seconds_precision(value) unless value.is_a?(::String)
-        return if value.empty?
-
-        dummy_time_value = value.sub(/\A(\d\d\d\d-\d\d-\d\d |)/, "2000-01-01 ")
-
-        fast_string_to_time(dummy_time_value) || begin
-          time_hash = ::Date._parse(dummy_time_value)
-          return if time_hash[:hour].nil?
-          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+        def cast_value(value)
+          return value unless value.is_a?(::String)
+          return if value.empty?
+
+          if value.start_with?("2000-01-01")
+            dummy_time_value = value
+          else
+            dummy_time_value = "2000-01-01 #{value}"
+          end
+
+          fast_string_to_time(dummy_time_value) || begin
+            time_hash = ::Date._parse(dummy_time_value)
+            return if time_hash[:hour].nil?
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+          end
         end
-      end
     end
   end
 end

data/lib/active_model/type/value.rb

@@ -105,12 +105,12 @@ module ActiveModel
 
       private
 
-      # Convenience method for types which do not need separate type casting
-      # behavior for user and database inputs. Called by Value#cast for
-      # values except +nil+.
-      def cast_value(value) # :doc:
-        value
-      end
+        # Convenience method for types which do not need separate type casting
+        # behavior for user and database inputs. Called by Value#cast for
+        # values except +nil+.
+        def cast_value(value) # :doc:
+          value
+        end
     end
   end
 end

data/lib/active_model/validations.rb

@@ -1,9 +1,8 @@
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/except'
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/except"
 
 module ActiveModel
-
   # == Active \Model \Validations
   #
   # Provides a full validation framework to your objects.
@@ -51,7 +50,7 @@ module ActiveModel
       define_callbacks :validate, scope: :name
 
       class_attribute :_validators, instance_writer: false
-      self._validators = Hash.new { |h,k| h[k] = [] }
+      self._validators = Hash.new { |h, k| h[k] = [] }
     end
 
     module ClassMethods
@@ -69,7 +68,7 @@ module ActiveModel
       #
       # Options:
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default (nil). You can pass a symbol
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
@@ -135,7 +134,7 @@ module ActiveModel
       #
       # Options:
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default (nil). You can pass a symbol
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
@@ -304,8 +303,6 @@ module ActiveModel
     # Runs all the specified validations and returns +true+ if no errors were
     # added otherwise +false+.
     #
-    # Aliased as validate.
-    #
     #   class Person
     #     include ActiveModel::Validations
     #
@@ -402,14 +399,14 @@ module ActiveModel
     #   end
     alias :read_attribute_for_validation :send
 
-  protected
+  private
 
-    def run_validations! #:nodoc:
+    def run_validations!
       _run_validate_callbacks
       errors.empty?
     end
 
-    def raise_validation_error
+    def raise_validation_error # :doc:
       raise(ValidationError.new(self))
     end
   end

data/lib/active_model/validations/absence.rb

@@ -22,7 +22,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validation#validates</tt> for more information
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_absence_of(*attr_names)
         validates_with AbsenceValidator, _merge_attributes(attr_names)
       end

data/lib/active_model/validations/acceptance.rb

@@ -1,5 +1,4 @@
 module ActiveModel
-
   module Validations
     class AcceptanceValidator < EachValidator # :nodoc:
       def initialize(options)
@@ -15,58 +14,60 @@ module ActiveModel
 
       private
 
-      def setup!(klass)
-        klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
-      end
+        def setup!(klass)
+          klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
+        end
 
-      def acceptable_option?(value)
-        Array(options[:accept]).include?(value)
-      end
+        def acceptable_option?(value)
+          Array(options[:accept]).include?(value)
+        end
 
-      class LazilyDefineAttributes < Module
-        def initialize(attribute_definition)
-          define_method(:respond_to_missing?) do |method_name, include_private=false|
-            super(method_name, include_private) || attribute_definition.matches?(method_name)
-          end
+        class LazilyDefineAttributes < Module
+          def initialize(attribute_definition)
+            define_method(:respond_to_missing?) do |method_name, include_private = false|
+              super(method_name, include_private) || attribute_definition.matches?(method_name)
+            end
 
-          define_method(:method_missing) do |method_name, *args, &block|
-            if attribute_definition.matches?(method_name)
-              attribute_definition.define_on(self.class)
-              send(method_name, *args, &block)
-            else
-              super(method_name, *args, &block)
+            define_method(:method_missing) do |method_name, *args, &block|
+              if attribute_definition.matches?(method_name)
+                attribute_definition.define_on(self.class)
+                send(method_name, *args, &block)
+              else
+                super(method_name, *args, &block)
+              end
             end
           end
         end
-      end
 
-      class AttributeDefinition
-        def initialize(attributes)
-          @attributes = attributes.map(&:to_s)
-        end
+        class AttributeDefinition
+          def initialize(attributes)
+            @attributes = attributes.map(&:to_s)
+          end
 
-        def matches?(method_name)
-          attr_name = convert_to_reader_name(method_name)
-          attributes.include?(attr_name)
-        end
+          def matches?(method_name)
+            attr_name = convert_to_reader_name(method_name)
+            attributes.include?(attr_name)
+          end
 
-        def define_on(klass)
-          attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-          attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-          klass.send(:attr_reader, *attr_readers)
-          klass.send(:attr_writer, *attr_writers)
-        end
+          def define_on(klass)
+            attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+            attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
+            klass.send(:attr_reader, *attr_readers)
+            klass.send(:attr_writer, *attr_writers)
+          end
 
-        protected
+          # TODO Change this to private once we've dropped Ruby 2.2 support.
+          # Workaround for Ruby 2.2 "private attribute?" warning.
+          protected
 
-        attr_reader :attributes
+            attr_reader :attributes
 
-        private
+          private
 
-        def convert_to_reader_name(method_name)
-          method_name.to_s.chomp('=')
+            def convert_to_reader_name(method_name)
+              method_name.to_s.chomp("=")
+            end
         end
-      end
     end
 
     module HelperMethods
@@ -94,7 +95,7 @@ module ActiveModel
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
-      # See <tt>ActiveModel::Validation#validates</tt> for more information.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information.
       def validates_acceptance_of(*attr_names)
         validates_with AcceptanceValidator, _merge_attributes(attr_names)
       end