activerecord 4.2.0 → 5.2.8.1

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

@@ -1,97 +1,90 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Array < Type::Value # :nodoc:
-          include Type::Mutable
+          include Type::Helpers::Mutable
 
-          # Loads pg_array_parser if available. String parsing can be
-          # performed quicker by a native extension, which will not create
-          # a large amount of Ruby objects that will need to be garbage
-          # collected. pg_array_parser has a C and Java extension
-          begin
-            require 'pg_array_parser'
-            include PgArrayParser
-          rescue LoadError
-            require 'active_record/connection_adapters/postgresql/array_parser'
-            include PostgreSQL::ArrayParser
-          end
+          Data = Struct.new(:encoder, :values) # :nodoc:
 
           attr_reader :subtype, :delimiter
-          delegate :type, to: :subtype
+          delegate :type, :user_input_in_time_zone, :limit, :precision, :scale, to: :subtype
 
-          def initialize(subtype, delimiter = ',')
+          def initialize(subtype, delimiter = ",")
             @subtype = subtype
             @delimiter = delimiter
+
+            @pg_encoder = PG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_decoder = PG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
           end
 
-          def type_cast_from_database(value)
-            if value.is_a?(::String)
-              type_cast_array(parse_pg_array(value), :type_cast_from_database)
+          def deserialize(value)
+            case value
+            when ::String
+              type_cast_array(@pg_decoder.decode(value), :deserialize)
+            when Data
+              type_cast_array(value.values, :deserialize)
             else
               super
             end
           end
 
-          def type_cast_from_user(value)
+          def cast(value)
             if value.is_a?(::String)
-              value = parse_pg_array(value)
+              value = begin
+                @pg_decoder.decode(value)
+              rescue TypeError
+                # malformed array string is treated as [], will raise in PG 2.0 gem
+                # this keeps a consistent implementation
+                []
+              end
             end
-            type_cast_array(value, :type_cast_from_user)
+            type_cast_array(value, :cast)
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Array)
-              cast_value_for_database(value)
+              casted_values = type_cast_array(value, :serialize)
+              Data.new(@pg_encoder, casted_values)
             else
               super
             end
           end
 
-          private
+          def ==(other)
+            other.is_a?(Array) &&
+              subtype == other.subtype &&
+              delimiter == other.delimiter
+          end
 
-          def type_cast_array(value, method)
-            if value.is_a?(::Array)
-              value.map { |item| type_cast_array(item, method) }
-            else
-              @subtype.public_send(method, value)
-            end
+          def type_cast_for_schema(value)
+            return super unless value.is_a?(::Array)
+            "[" + value.map { |v| subtype.type_cast_for_schema(v) }.join(", ") + "]"
           end
 
-          def cast_value_for_database(value)
-            if value.is_a?(::Array)
-              casted_values = value.map { |item| cast_value_for_database(item) }
-              "{#{casted_values.join(delimiter)}}"
-            else
-              quote_and_escape(subtype.type_cast_for_database(value))
-            end
+          def map(value, &block)
+            value.map(&block)
           end
 
-          ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
 
-          def quote_and_escape(value)
-            case value
-            when ::String
-              if string_requires_quoting?(value)
-                value = value.gsub(/\\/, ARRAY_ESCAPE)
-                value.gsub!(/"/,"\\\"")
-                %("#{value}")
+          def force_equality?(value)
+            value.is_a?(::Array)
+          end
+
+          private
+
+            def type_cast_array(value, method)
+              if value.is_a?(::Array)
+                value.map { |item| type_cast_array(item, method) }
               else
-                value
+                @subtype.public_send(method, value)
               end
-            when nil then "NULL"
-            else value
             end
-          end
-
-          # See http://www.postgresql.org/docs/9.2/static/arrays.html#ARRAYS-IO
-          # for a list of all cases in which strings will be quoted.
-          def string_requires_quoting?(string)
-            string.empty? ||
-              string == "NULL" ||
-              string =~ /[\{\}"\\\s]/ ||
-              string.include?(delimiter)
-          end
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -7,7 +9,7 @@ module ActiveRecord
             :bit
           end
 
-          def type_cast(value)
+          def cast_value(value)
             if ::String === value
               case value
               when /^0x/i
@@ -16,11 +18,11 @@ module ActiveRecord
                 value                    # Bit-string notation
               end
             else
-              value
+              value.to_s
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             Data.new(super) if value
           end
 
@@ -34,16 +36,18 @@ module ActiveRecord
             end
 
             def binary?
-              /\A[01]*\Z/ === value
+              /\A[01]*\Z/.match?(value)
             end
 
             def hex?
-              /\A[0-9A-F]*\Z/i === value
+              /\A[0-9A-F]*\Z/i.match?(value)
             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 :value
+              attr_reader :value
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL

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

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Bytea < Type::Binary # :nodoc:
-          def type_cast_from_database(value)
+          def deserialize(value)
             return if value.nil?
-            PGconn.unescape_bytea(super)
+            return value.to_s if value.is_a?(Type::Binary::Data)
+            PG::Connection.unescape_bytea(super)
           end
         end
       end

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

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -18,7 +22,7 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if IPAddr === value
               "#{value}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
             else

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

@@ -1,9 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Date < Type::Date # :nodoc:
-          include Infinity
+          def cast_value(value)
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+            else
+              super
+            end
+          end
         end
       end
     end

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

@@ -1,23 +1,19 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class DateTime < Type::DateTime # :nodoc:
-          include Infinity
-
           def cast_value(value)
-            if value.is_a?(::String)
-              case value
-              when 'infinity' then ::Float::INFINITY
-              when '-infinity' then -::Float::INFINITY
-              when / BC$/
-                astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
-                super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
-              else
-                super
-              end
+            case value
+            when "infinity" then ::Float::INFINITY
+            when "-infinity" then -::Float::INFINITY
+            when / BC$/
+              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
             else
-              value
+              super
             end
           end
         end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Decimal < Type::Decimal # :nodoc:
           def infinity(options = {})
-            BigDecimal.new("Infinity") * (options[:negative] ? -1 : 1)
+            BigDecimal("Infinity") * (options[:negative] ? -1 : 1)
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -7,9 +9,11 @@ module ActiveRecord
             :enum
           end
 
-          def type_cast(value)
-            value.to_s
-          end
+          private
+
+            def cast_value(value)
+              value.to_s
+            end
         end
       end
     end

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

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
-          include Type::Mutable
+          include Type::Helpers::Mutable
 
           def type
             :hstore
           end
 
-          def type_cast_from_database(value)
+          def deserialize(value)
             if value.is_a?(::String)
               ::Hash[value.scan(HstorePair).map { |k, v|
-                v = v.upcase == 'NULL' ? nil : v.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
-                k = k.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
+                v = v.upcase == "NULL" ? nil : v.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
+                k = k.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
                 [k, v]
               }]
             else
@@ -21,9 +23,11 @@ module ActiveRecord
             end
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Hash)
-              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
+              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(", ")
+            elsif value.respond_to?(:to_unsafe_h)
+              serialize(value.to_unsafe_h)
             else
               value
             end
@@ -33,25 +37,33 @@ module ActiveRecord
             ActiveRecord::Store::StringKeyedHashAccessor
           end
 
+          # Will compare the Hash equivalents of +raw_old_value+ and +new_value+.
+          # By comparing hashes, this avoids an edge case where the order of
+          # the keys change between the two hashes, and they would not be marked
+          # as equal.
+          def changed_in_place?(raw_old_value, new_value)
+            deserialize(raw_old_value) != new_value
+          end
+
           private
 
-          HstorePair = begin
-            quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
-            unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
-            /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
-          end
+            HstorePair = begin
+              quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+              unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+              /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
+            end
 
-          def escape_hstore(value)
-            if value.nil?
-              'NULL'
-            else
-              if value == ""
-                '""'
+            def escape_hstore(value)
+              if value.nil?
+                "NULL"
               else
-                '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                if value == ""
+                  '""'
+                else
+                  '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                end
               end
             end
-          end
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL

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

@@ -1,21 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Jsonb < Json # :nodoc:
+        class Jsonb < Type::Json # :nodoc:
           def type
             :jsonb
           end
-
-          def changed_in_place?(raw_old_value, new_value)
-            # Postgres does not preserve insignificant whitespaces when
-            # roundtripping jsonb columns. This causes some false positives for
-            # the comparison here. Therefore, we need to parse and re-dump the
-            # raw value here to ensure the insignificant whitespaces are
-            # consistent with our encoder's output.
-            raw_old_value = type_cast_for_database(type_cast_from_database(raw_old_value))
-            super(raw_old_value, new_value)
-          end
         end
       end
     end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class LegacyPoint < Type::Value # :nodoc:
+          include Type::Helpers::Mutable
+
+          def type
+            :point
+          end
+
+          def cast(value)
+            case value
+            when ::String
+              if value[0] == "(" && value[-1] == ")"
+                value = value[1...-1]
+              end
+              cast(value.split(","))
+            when ::Array
+              value.map { |v| Float(v) }
+            else
+              value
+            end
+          end
+
+          def serialize(value)
+            if value.is_a?(::Array)
+              "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
+            else
+              super
+            end
+          end
+
+          private
+
+            def number_for_point(number)
+              number.to_s.gsub(/\.0$/, "")
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Money < Type::Decimal # :nodoc:
-          include Infinity
-
-          class_attribute :precision
-
           def type
             :money
           end
@@ -26,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/{integer.rb → oid.rb}

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Integer < Type::Integer # :nodoc:
-          include Infinity
+        class Oid < Type::Integer # :nodoc:
+          def type
+            :oid
+          end
         end
       end
     end

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

@@ -1,31 +1,49 @@
+# 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::Mutable
+          include Type::Helpers::Mutable
 
           def type
             :point
           end
 
-          def type_cast(value)
+          def cast(value)
             case value
             when ::String
-              if value[0] == '(' && value[-1] == ')'
+              return if value.blank?
+
+              if value[0] == "(" && value[-1] == ")"
                 value = value[1...-1]
               end
-              type_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 type_cast_for_database(value)
-            if value.is_a?(::Array)
-              "(#{number_for_point(value[0])},#{number_for_point(value[1])})"
+          def serialize(value)
+            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
@@ -33,9 +51,13 @@ module ActiveRecord
 
           private
 
-          def number_for_point(number)
-            number.to_s.gsub(/\.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