activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/type/adapter_specific_registry.rb

@@ -1,4 +1,6 @@
-require 'active_model/type/registry'
+# frozen_string_literal: true
+
+require "active_model/type/registry"
 
 module ActiveRecord
   # :stopdoc:
@@ -9,16 +11,15 @@ module ActiveRecord
       end
 
       private
+        def registration_klass
+          Registration
+        end
 
-      def registration_klass
-        Registration
-      end
-
-      def find_registration(symbol, *args)
-        registrations
-          .select { |registration| registration.matches?(symbol, *args) }
-          .max
-      end
+        def find_registration(symbol, *args, **kwargs)
+          registrations
+            .select { |registration| registration.matches?(symbol, *args, **kwargs) }
+            .max
+        end
     end
 
     class Registration
@@ -51,43 +52,41 @@ module ActiveRecord
       end
 
       protected
-
-      attr_reader :name, :block, :adapter, :override
-
-      def priority
-        result = 0
-        if adapter
-          result |= 1
-        end
-        if override
-          result |= 2
+        attr_reader :name, :block, :adapter, :override
+
+        def priority
+          result = 0
+          if adapter
+            result |= 1
+          end
+          if override
+            result |= 2
+          end
+          result
         end
-        result
-      end
 
-      def priority_except_adapter
-        priority & 0b111111100
-      end
+        def priority_except_adapter
+          priority & 0b111111100
+        end
 
       private
+        def matches_adapter?(adapter: nil, **)
+          (self.adapter.nil? || adapter == self.adapter)
+        end
 
-      def matches_adapter?(adapter: nil, **)
-        (self.adapter.nil? || adapter == self.adapter)
-      end
-
-      def conflicts_with?(other)
-        same_priority_except_adapter?(other) &&
-          has_adapter_conflict?(other)
-      end
+        def conflicts_with?(other)
+          same_priority_except_adapter?(other) &&
+            has_adapter_conflict?(other)
+        end
 
-      def same_priority_except_adapter?(other)
-        priority_except_adapter == other.priority_except_adapter
-      end
+        def same_priority_except_adapter?(other)
+          priority_except_adapter == other.priority_except_adapter
+        end
 
-      def has_adapter_conflict?(other)
-        (override.nil? && other.adapter) ||
-          (adapter && other.override.nil?)
-      end
+        def has_adapter_conflict?(other)
+          (override.nil? && other.adapter) ||
+            (adapter && other.override.nil?)
+        end
     end
 
     class DecorationRegistration < Registration
@@ -110,17 +109,14 @@ module ActiveRecord
         super | 4
       end
 
-      protected
-
-      attr_reader :options, :klass
-
       private
+        attr_reader :options, :klass
 
-      def matches_options?(**kwargs)
-        options.all? do |key, value|
-          kwargs[key] == value
+        def matches_options?(**kwargs)
+          options.all? do |key, value|
+            kwargs[key] == value
+          end
         end
-      end
     end
   end
 

data/lib/active_record/type/date.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class Date < ActiveModel::Type::Date

data/lib/active_record/type/date_time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class DateTime < ActiveModel::Type::DateTime

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < ActiveModel::Type::BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
+    end
+  end
+end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class HashLookupTypeMap < TypeMap # :nodoc:
@@ -14,10 +16,9 @@ module ActiveRecord
       end
 
       private
-
-      def perform_fetch(type, *args, &block)
-        @mapping.fetch(type, block).call(type, *args)
-      end
+        def perform_fetch(type, *args, &block)
+          @mapping.fetch(type, block).call(type, *args)
+        end
     end
   end
 end

data/lib/active_record/type/internal/timezone.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     module Internal

data/lib/active_record/type/json.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Json < ActiveModel::Type::Value
+      include ActiveModel::Type::Helpers::Mutable
+
+      def type
+        :json
+      end
+
+      def deserialize(value)
+        return value unless value.is_a?(::String)
+        ActiveSupport::JSON.decode(value) rescue nil
+      end
+
+      def serialize(value)
+        ActiveSupport::JSON.encode(value) unless value.nil?
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        deserialize(raw_old_value) != new_value
+      end
+
+      def accessor
+        ActiveRecord::Store::StringKeyedHashAccessor
+      end
+    end
+  end
+end

data/lib/active_record/type/serialized.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      undef to_yaml if method_defined?(:to_yaml)
+
       include ActiveModel::Type::Helpers::Mutable
 
       attr_reader :subtype, :coder
@@ -43,21 +47,28 @@ module ActiveRecord
 
       def assert_valid_value(value)
         if coder.respond_to?(:assert_valid_value)
-          coder.assert_valid_value(value)
+          coder.assert_valid_value(value, action: "serialize")
         end
       end
 
-      private
-
-      def default_value?(value)
-        value == coder.load(nil)
+      def force_equality?(value)
+        coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
       end
 
-      def encoded(value)
-        unless default_value?(value)
-          coder.dump(value)
+      private
+        def default_value?(value)
+          value == coder.load(nil)
+        end
+
+        def encoded(value)
+          return if default_value?(value)
+          payload = coder.dump(value)
+          if payload && binary? && payload.encoding != Encoding::BINARY
+            payload = payload.dup if payload.frozen?
+            payload.force_encoding(Encoding::BINARY)
+          end
+          payload
         end
-      end
     end
   end
 end

data/lib/active_record/type/text.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Text < ActiveModel::Type::String # :nodoc:
+      def type
+        :text
+      end
+    end
+  end
+end

data/lib/active_record/type/time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Type
     class Time < ActiveModel::Type::Time
@@ -14,7 +16,16 @@ module ActiveRecord
           value
         end
       end
+
+      private
+        def cast_value(value)
+          case value = super
+          when Value
+            value.__getobj__
+          else
+            value
+          end
+        end
     end
   end
 end
-

data/lib/active_record/type/type_map.rb

@@ -1,4 +1,6 @@
-require 'concurrent/map'
+# frozen_string_literal: true
+
+require "concurrent/map"
 
 module ActiveRecord
   module Type
@@ -11,7 +13,7 @@ module ActiveRecord
       end
 
       def lookup(lookup_key, *args)
-        fetch(lookup_key, *args) { default_value }
+        fetch(lookup_key, *args) { Type.default_value }
       end
 
       def fetch(lookup_key, *args, &block)
@@ -43,22 +45,17 @@ module ActiveRecord
       end
 
       private
-
-      def perform_fetch(lookup_key, *args)
-        matching_pair = @mapping.reverse_each.detect do |key, _|
-          key === lookup_key
-        end
-
-        if matching_pair
-          matching_pair.last.call(lookup_key, *args)
-        else
-          yield lookup_key, *args
+        def perform_fetch(lookup_key, *args)
+          matching_pair = @mapping.reverse_each.detect do |key, _|
+            key === lookup_key
+          end
+
+          if matching_pair
+            matching_pair.last.call(lookup_key, *args)
+          else
+            yield lookup_key, *args
+          end
         end
-      end
-
-      def default_value
-        @default_value ||= ActiveModel::Type::Value.new
-      end
     end
   end
 end

data/lib/active_record/type/unsigned_integer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class UnsignedInteger < ActiveModel::Type::Integer # :nodoc:
+      private
+        def max_value
+          super * 2
+        end
+
+        def min_value
+          0
+        end
+    end
+  end
+end

data/lib/active_record/type_caster.rb

@@ -1,5 +1,7 @@
-require 'active_record/type_caster/map'
-require 'active_record/type_caster/connection'
+# frozen_string_literal: true
+
+require "active_record/type_caster/map"
+require "active_record/type_caster/connection"
 
 module ActiveRecord
   module TypeCaster # :nodoc:

data/lib/active_record/type_caster/connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module TypeCaster
     class Connection # :nodoc:
@@ -6,24 +8,26 @@ module ActiveRecord
         @table_name = table_name
       end
 
-      def type_cast_for_database(attribute_name, value)
-        return value if value.is_a?(Arel::Nodes::BindParam)
-        column = column_for(attribute_name)
-        connection.type_cast_from_column(column, value)
+      def type_cast_for_database(attr_name, value)
+        type = type_for_attribute(attr_name)
+        type.serialize(value)
       end
 
-      protected
-
-      attr_reader :table_name
-      delegate :connection, to: :@klass
-
-      private
+      def type_for_attribute(attr_name)
+        schema_cache = connection.schema_cache
 
-      def column_for(attribute_name)
-        if connection.schema_cache.data_source_exists?(table_name)
-          connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]
+        if schema_cache.data_source_exists?(table_name)
+          column = schema_cache.columns_hash(table_name)[attr_name.to_s]
+          type = connection.lookup_cast_type_from_column(column) if column
         end
+
+        type || Type.default_value
       end
+
+      delegate :connection, to: :@klass, private: true
+
+      private
+        attr_reader :table_name
     end
   end
 end

data/lib/active_record/type_caster/map.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module TypeCaster
     class Map # :nodoc:
-      def initialize(types)
-        @types = types
+      def initialize(klass)
+        @klass = klass
       end
 
       def type_cast_for_database(attr_name, value)
-        return value if value.is_a?(Arel::Nodes::BindParam)
-        type = types.type_for_attribute(attr_name.to_s)
+        type = type_for_attribute(attr_name)
         type.serialize(value)
       end
 
-      protected
+      def type_for_attribute(name)
+        klass.type_for_attribute(name)
+      end
 
-      attr_reader :types
+      private
+        attr_reader :klass
     end
   end
 end