activerecord 6.0.1

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

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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Cidr < Type::Value # :nodoc:
+          def type
+            :cidr
+          end
+
+          def type_cast_for_schema(value)
+            subnet_mask = value.instance_variable_get(:@mask_addr)
+
+            # If the subnet mask is equal to /32, don't output it
+            if subnet_mask == (2**32 - 1)
+              "\"#{value}\""
+            else
+              "\"#{value}/#{subnet_mask.to_s(2).count('1')}\""
+            end
+          end
+
+          def serialize(value)
+            if IPAddr === value
+              "#{value}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+            else
+              value
+            end
+          end
+
+          def cast_value(value)
+            if value.nil?
+              nil
+            elsif String === value
+              begin
+                IPAddr.new(value)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Date < Type::Date # :nodoc:
+          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
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          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
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Enum < Type::Value # :nodoc:
+          def type
+            :enum
+          end
+
+          private
+
+            def cast_value(value)
+              value.to_s
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Hstore < Type::Value # :nodoc:
+          include ActiveModel::Type::Helpers::Mutable
+
+          def type
+            :hstore
+          end
+
+          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')
+                [k, v]
+              }]
+            else
+              value
+            end
+          end
+
+          def serialize(value)
+            if value.is_a?(::Hash)
+              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
+          end
+
+          def accessor
+            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
+
+            def escape_hstore(value)
+              if value.nil?
+                "NULL"
+              else
+                if value == ""
+                  '""'
+                else
+                  '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+                end
+              end
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Inet < Cidr # :nodoc:
+          def type
+            :inet
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Jsonb < Type::Json # :nodoc:
+          def type
+            :jsonb
+          end
+        end
+      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 ActiveModel::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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Money < Type::Decimal # :nodoc:
+          def type
+            :money
+          end
+
+          def scale
+            2
+          end
+
+          def cast_value(value)
+            return value unless ::String === value
+
+            # Because money output is formatted according to the locale, there are two
+            # cases to consider (note the decimal separators):
+            #  (1) $12,345,678.12
+            #  (2) $12.345.678,12
+            # Negative values are represented as follows:
+            #  (3) -$2.55
+            #  (4) ($2.55)
+
+            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!(/,/, ".")
+            end
+
+            super(value)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  Point = Struct.new(:x, :y)
+
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Point < Type::Value # :nodoc:
+          include ActiveModel::Type::Helpers::Mutable
+
+          def type
+            :point
+          end
+
+          def cast(value)
+            case value
+            when ::String
+              return if value.blank?
+
+              if value[0] == "(" && value[-1] == ")"
+                value = value[1...-1]
+              end
+              x, y = value.split(",")
+              build_point(x, y)
+            when ::Array
+              build_point(*value)
+            else
+              value
+            end
+          end
+
+          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
+          end
+
+          private
+
+            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
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Range < Type::Value # :nodoc:
+          attr_reader :subtype, :type
+          delegate :user_input_in_time_zone, to: :subtype
+
+          def initialize(subtype, type = :range)
+            @subtype = subtype
+            @type = type
+          end
+
+          def type_cast_for_schema(value)
+            value.inspect.gsub("Infinity", "::Float::INFINITY")
+          end
+
+          def cast_value(value)
+            return if value == "empty"
+            return value unless value.is_a?(::String)
+
+            extracted = extract_bounds(value)
+            from = type_cast_single extracted[:from]
+            to = type_cast_single extracted[:to]
+
+            if !infinity?(from) && extracted[:exclude_start]
+              raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
+            end
+            ::Range.new(from, to, extracted[:exclude_end])
+          end
+
+          def serialize(value)
+            if value.is_a?(::Range)
+              from = type_cast_single_for_database(value.begin)
+              to = type_cast_single_for_database(value.end)
+              ::Range.new(from, to, value.exclude_end?)
+            else
+              super
+            end
+          end
+
+          def ==(other)
+            other.is_a?(Range) &&
+              other.subtype == subtype &&
+              other.type == type
+          end
+
+          def map(value) # :nodoc:
+            new_begin = yield(value.begin)
+            new_end = yield(value.end)
+            ::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_for_database(value)
+              infinity?(value) ? value : @subtype.serialize(@subtype.cast(value))
+            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
+
+            def infinity(negative: false)
+              if subtype.respond_to?(:infinity)
+                subtype.infinity(negative: negative)
+              elsif negative
+                -::Float::INFINITY
+              else
+                ::Float::INFINITY
+              end
+            end
+
+            def infinity?(value)
+              value.respond_to?(:infinite?) && value.infinite?
+            end
+        end
+      end
+    end
+  end
+end