activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/connection_adapters/postgresql/oid/macaddr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Macaddr < Type::String # :nodoc:
+          def type
+            :macaddr
+          end
+
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value && old_value.casecmp(new_value) != 0
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value && raw_old_value.casecmp(new_value) != 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/oid/money.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -22,12 +24,12 @@ module ActiveRecord
             #  (3) -$2.55
             #  (4) ($2.55)
 
-            value.sub!(/^\((.+)\)$/, '-\1') # (4)
+            value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
-            when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-              value.gsub!(/[^-\d.]/, '')
-            when /^-?\D+[\d.]+,\d{2}$/  # (2)
-              value.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+            when /^-?\D*[\d,]+\.\d{2}$/  # (1)
+              value.gsub!(/[^-\d.]/, "")
+            when /^-?\D*[\d.]+,\d{2}$/  # (2)
+              value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
             end
 
             super(value)

data/lib/active_record/connection_adapters/postgresql/oid/{json.rb → oid.rb}

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Json < Type::Internal::AbstractJson
+        class Oid < Type::UnsignedInteger # :nodoc:
+          def type
+            :oid
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/point.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
+  Point = Struct.new(:x, :y)
+
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Point < Type::Value # :nodoc:
-          include Type::Helpers::Mutable
+          include ActiveModel::Type::Helpers::Mutable
 
           def type
             :point
@@ -12,30 +16,47 @@ module ActiveRecord
           def cast(value)
             case value
             when ::String
-              if value[0] == '(' && value[-1] == ')'
+              return if value.blank?
+
+              if value.start_with?("(") && value.end_with?(")")
                 value = value[1...-1]
               end
-              cast(value.split(','))
+              x, y = value.split(",")
+              build_point(x, y)
             when ::Array
-              value.map { |v| Float(v) }
+              build_point(*value)
             else
               value
             end
           end
 
           def serialize(value)
-            if value.is_a?(::Array)
-              "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
+            case value
+            when ActiveRecord::Point
+              "(#{number_for_point(value.x)},#{number_for_point(value.y)})"
+            when ::Array
+              serialize(build_point(*value))
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            if ActiveRecord::Point === value
+              [value.x, value.y]
             else
               super
             end
           end
 
           private
+            def number_for_point(number)
+              number.to_s.delete_suffix(".0")
+            end
 
-          def number_for_point(number)
-            number.to_s.gsub(/\.0$/, '')
-          end
+            def build_point(x, y)
+              ActiveRecord::Point.new(Float(x), Float(y))
+            end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
@@ -14,11 +14,11 @@ module ActiveRecord
           end
 
           def type_cast_for_schema(value)
-            value.inspect.gsub('Infinity', '::Float::INFINITY')
+            value.inspect.gsub("Infinity", "::Float::INFINITY")
           end
 
           def cast_value(value)
-            return if value == 'empty'
+            return if value == "empty"
             return value unless value.is_a?(::String)
 
             extracted = extract_bounds(value)
@@ -35,7 +35,7 @@ module ActiveRecord
             if value.is_a?(::Range)
               from = type_cast_single_for_database(value.begin)
               to = type_cast_single_for_database(value.end)
-              "[#{from},#{to}#{value.exclude_end? ? ')' : ']'}"
+              ::Range.new(from, to, value.exclude_end?)
             else
               super
             end
@@ -53,39 +53,61 @@ module ActiveRecord
             ::Range.new(new_begin, new_end, value.exclude_end?)
           end
 
+          def force_equality?(value)
+            value.is_a?(::Range)
+          end
+
           private
+            def type_cast_single(value)
+              infinity?(value) ? value : @subtype.deserialize(value)
+            end
 
-          def type_cast_single(value)
-            infinity?(value) ? value : @subtype.deserialize(value)
-          end
+            def type_cast_single_for_database(value)
+              infinity?(value) ? value : @subtype.serialize(@subtype.cast(value))
+            end
 
-          def type_cast_single_for_database(value)
-            infinity?(value) ? '' : @subtype.serialize(value)
-          end
+            def extract_bounds(value)
+              from, to = value[1..-2].split(",", 2)
+              {
+                from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
+                to:            (to == "" || to == "infinity") ? infinity : unquote(to),
+                exclude_start: value.start_with?("("),
+                exclude_end:   value.end_with?(")")
+              }
+            end
 
-          def extract_bounds(value)
-            from, to = value[1..-2].split(',')
-            {
-              from:          (value[1] == ',' || from == '-infinity') ? infinity(negative: true) : from,
-              to:            (value[-2] == ',' || to == 'infinity') ? infinity : to,
-              exclude_start: (value[0] == '('),
-              exclude_end:   (value[-1] == ')')
-            }
-          end
+            # When formatting the bound values of range types, PostgreSQL quotes
+            # the bound value using double-quotes in certain conditions. Within
+            # a double-quoted string, literal " and \ characters are themselves
+            # escaped. In input, PostgreSQL accepts multiple escape styles for "
+            # (either \" or "") but in output always uses "".
+            # See:
+            # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
+            # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
+            def unquote(value)
+              if value.start_with?('"') && value.end_with?('"')
+                unquoted_value = value[1..-2]
+                unquoted_value.gsub!('""', '"')
+                unquoted_value.gsub!('\\\\', '\\')
+                unquoted_value
+              else
+                value
+              end
+            end
 
-          def infinity(negative: false)
-            if subtype.respond_to?(:infinity)
-              subtype.infinity(negative: negative)
-            elsif negative
-              -::Float::INFINITY
-            else
-              ::Float::INFINITY
+            def infinity(negative: false)
+              if subtype.respond_to?(:infinity)
+                subtype.infinity(negative: negative)
+              elsif negative
+                -::Float::INFINITY
+              else
+                ::Float::INFINITY
+              end
             end
-          end
 
-          def infinity?(value)
-            value.respond_to?(:infinite?) && value.infinite?
-          end
+            def infinity?(value)
+              value.respond_to?(:infinite?) && value.infinite?
+            end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -5,8 +7,9 @@ module ActiveRecord
         class SpecializedString < Type::String # :nodoc:
           attr_reader :type
 
-          def initialize(type)
+          def initialize(type, **options)
             @type = type
+            super(**options)
           end
         end
       end

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -13,13 +17,13 @@ module ActiveRecord
           end
 
           def run(records)
-            nodes = records.reject { |row| @store.key? row['oid'].to_i }
-            mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
-            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r'.freeze }
-            enums, nodes = nodes.partition { |row| row['typtype'] == 'e'.freeze }
-            domains, nodes = nodes.partition { |row| row['typtype'] == 'd'.freeze }
-            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in'.freeze }
-            composites, nodes = nodes.partition { |row| row['typelem'].to_i != 0 }
+            nodes = records.reject { |row| @store.key? row["oid"].to_i }
+            mapped = nodes.extract! { |row| @store.key? row["typname"] }
+            ranges = nodes.extract! { |row| row["typtype"] == "r" }
+            enums = nodes.extract! { |row| row["typtype"] == "e" }
+            domains = nodes.extract! { |row| row["typtype"] == "d" }
+            arrays = nodes.extract! { |row| row["typinput"] == "array_in" }
+            composites = nodes.extract! { |row| row["typelem"].to_i != 0 }
 
             mapped.each     { |row| register_mapped_type(row)    }
             enums.each      { |row| register_enum_type(row)      }
@@ -29,10 +33,10 @@ module ActiveRecord
             composites.each { |row| register_composite_type(row) }
           end
 
-          def query_conditions_for_initial_load(type_map)
-            known_type_names = type_map.keys.map { |n| "'#{n}'" }
+          def query_conditions_for_initial_load
+            known_type_names = @store.keys.map { |n| "'#{n}'" }
             known_type_types = %w('r' 'e' 'd')
-            <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
+            <<~SQL % [known_type_names.join(", "), known_type_types.join(", ")]
               WHERE
                 t.typname IN (%s)
                 OR t.typtype IN (%s)
@@ -42,66 +46,66 @@ module ActiveRecord
           end
 
           private
-          def register_mapped_type(row)
-            alias_type row['oid'], row['typname']
-          end
+            def register_mapped_type(row)
+              alias_type row["oid"], row["typname"]
+            end
 
-          def register_enum_type(row)
-            register row['oid'], OID::Enum.new
-          end
+            def register_enum_type(row)
+              register row["oid"], OID::Enum.new
+            end
 
-          def register_array_type(row)
-            register_with_subtype(row['oid'], row['typelem'].to_i) do |subtype|
-              OID::Array.new(subtype, row['typdelim'])
+            def register_array_type(row)
+              register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
+                OID::Array.new(subtype, row["typdelim"])
+              end
             end
-          end
 
-          def register_range_type(row)
-            register_with_subtype(row['oid'], row['rngsubtype'].to_i) do |subtype|
-              OID::Range.new(subtype, row['typname'].to_sym)
+            def register_range_type(row)
+              register_with_subtype(row["oid"], row["rngsubtype"].to_i) do |subtype|
+                OID::Range.new(subtype, row["typname"].to_sym)
+              end
             end
-          end
 
-          def register_domain_type(row)
-            if base_type = @store.lookup(row["typbasetype"].to_i)
-              register row['oid'], base_type
-            else
-              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+            def register_domain_type(row)
+              if base_type = @store.lookup(row["typbasetype"].to_i)
+                register row["oid"], base_type
+              else
+                warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+              end
             end
-          end
 
-          def register_composite_type(row)
-            if subtype = @store.lookup(row['typelem'].to_i)
-              register row['oid'], OID::Vector.new(row['typdelim'], subtype)
+            def register_composite_type(row)
+              if subtype = @store.lookup(row["typelem"].to_i)
+                register row["oid"], OID::Vector.new(row["typdelim"], subtype)
+              end
             end
-          end
 
-          def register(oid, oid_type = nil, &block)
-            oid = assert_valid_registration(oid, oid_type || block)
-            if block_given?
-              @store.register_type(oid, &block)
-            else
-              @store.register_type(oid, oid_type)
+            def register(oid, oid_type = nil, &block)
+              oid = assert_valid_registration(oid, oid_type || block)
+              if block_given?
+                @store.register_type(oid, &block)
+              else
+                @store.register_type(oid, oid_type)
+              end
             end
-          end
 
-          def alias_type(oid, target)
-            oid = assert_valid_registration(oid, target)
-            @store.alias_type(oid, target)
-          end
+            def alias_type(oid, target)
+              oid = assert_valid_registration(oid, target)
+              @store.alias_type(oid, target)
+            end
 
-          def register_with_subtype(oid, target_oid)
-            if @store.key?(target_oid)
-              register(oid) do |_, *args|
-                yield @store.lookup(target_oid, *args)
+            def register_with_subtype(oid, target_oid)
+              if @store.key?(target_oid)
+                register(oid) do |_, *args|
+                  yield @store.lookup(target_oid, *args)
+                end
               end
             end
-          end
 
-          def assert_valid_registration(oid, oid_type)
-            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
-            oid.to_i
-          end
+            def assert_valid_registration(oid, oid_type)
+              raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
+              oid.to_i
+            end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/uuid.rb

@@ -1,19 +1,33 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Uuid < Type::Value # :nodoc:
-          ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
+          ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
 
-          alias_method :serialize, :deserialize
+          alias :serialize :deserialize
 
           def type
             :uuid
           end
 
-          def cast(value)
-            value.to_s[ACCEPTABLE_UUID, 0]
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value && old_value.casecmp(new_value) != 0
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value && raw_old_value.casecmp(new_value) != 0
           end
+
+          private
+            def cast_value(value)
+              casted = value.to_s
+              casted if casted.match?(ACCEPTABLE_UUID)
+            end
         end
       end
     end