activerecord-cipherstash-pg-adapter 0.1.0

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Bit < Type::Value # :nodoc:
+          def type
+            :bit
+          end
+
+          def cast_value(value)
+            if ::String === value
+              case value
+              when /^0x/i
+                value[2..-1].hex.to_s(2) # Hexadecimal notation
+              else
+                value                    # Bit-string notation
+              end
+            else
+              value.to_s
+            end
+          end
+
+          def serialize(value)
+            Data.new(super) if value
+          end
+
+          class Data
+            def initialize(value)
+              @value = value
+            end
+
+            def to_s
+              value
+            end
+
+            def binary?
+              /\A[01]*\Z/.match?(value)
+            end
+
+            def hex?
+              /\A[0-9A-F]*\Z/i.match?(value)
+            end
+
+            private
+              attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class BitVarying < OID::Bit # :nodoc:
+          def type
+            :bit_varying
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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/cipherstash_pg/oid/cidr.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Cidr < Type::Value # :nodoc:
+          def type
+            :cidr
+          end
+
+          def type_cast_for_schema(value)
+            # If the subnet mask is equal to /32, don't output it
+            if value.prefix == 32
+              "\"#{value}\""
+            else
+              "\"#{value}/#{value.prefix}\""
+            end
+          end
+
+          def serialize(value)
+            if IPAddr === value
+              "#{value}/#{value.prefix}"
+            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/cipherstash_pg/oid/date.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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$/
+              value = value.sub(/^\d+/) { |year| format("%04d", -year.to_i + 1) }
+              super(value.delete_suffix!(" BC"))
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
+
+          protected
+            def real_type_unless_aliased(real_type)
+              ActiveRecord::ConnectionAdapters::CipherStashPGAdapter.datetime_type == real_type ? :datetime : real_type
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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/cipherstash_pg/oid/enum.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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/cipherstash_pg/oid/hstore.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Hstore < Type::Value # :nodoc:
+          ERROR = "Invalid Hstore document: %s"
+
+          include ActiveModel::Type::Helpers::Mutable
+
+          def type
+            :hstore
+          end
+
+          def deserialize(value)
+            return value unless value.is_a?(::String)
+
+            scanner = StringScanner.new(value)
+            hash = {}
+
+            until scanner.eos?
+              unless scanner.skip(/"/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless key = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless scanner.skip(/"=>?/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              if scanner.scan(/NULL/)
+                value = nil
+              else
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless value = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+              end
+
+              key.gsub!('\"', '"')
+              key.gsub!("\\\\", "\\")
+
+              if value
+                value.gsub!('\"', '"')
+                value.gsub!("\\\\", "\\")
+              end
+
+              hash[key] = value
+
+              unless scanner.skip(/, /) || scanner.eos?
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+            end
+
+            hash
+          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
+            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/cipherstash_pg/oid/inet.rb

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

data/lib/active_record/connection_adapters/cipherstash_pg/oid/interval.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/duration"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Interval < Type::Value # :nodoc:
+          def type
+            :interval
+          end
+
+          def cast_value(value)
+            case value
+            when ::ActiveSupport::Duration
+              value
+            when ::String
+              begin
+                ::ActiveSupport::Duration.parse(value)
+              rescue ::ActiveSupport::Duration::ISO8601Parser::ParsingError
+                nil
+              end
+            else
+              super
+            end
+          end
+
+          def serialize(value)
+            case value
+            when ::ActiveSupport::Duration
+              value.iso8601(precision: self.precision)
+            when ::Numeric
+              # Sometimes operations on Times returns just float number of seconds so we need to handle that.
+              # Example: Time.current - (Time.current + 1.hour) # => -3600.000001776 (Float)
+              value.seconds.iso8601(precision: self.precision)
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            serialize(value).inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      module OID # :nodoc:
+        class Jsonb < Type::Json # :nodoc:
+          def type
+            :jsonb
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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.start_with?("(") && value.end_with?(")")
+                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.delete_suffix(".0")
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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/cipherstash_pg/oid/money.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CipherStashPG
+      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/cipherstash_pg/oid/oid.rb

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

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  Point = Struct.new(:x, :y)
+
+  module ConnectionAdapters
+    module CipherStashPG
+      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.start_with?("(") && value.end_with?(")")
+                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.delete_suffix(".0")
+            end
+
+            def build_point(x, y)
+              ActiveRecord::Point.new(Float(x), Float(y))
+            end
+        end
+      end
+    end
+  end
+end