activerecord 4.1.16 → 4.2.0.beta1

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

@@ -0,0 +1,96 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Array < Type::Value # :nodoc:
+          include Type::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
+
+          attr_reader :subtype, :delimiter
+          delegate :type, to: :subtype
+
+          def initialize(subtype, delimiter = ',')
+            @subtype = subtype
+            @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)
+            else
+              super
+            end
+          end
+
+          def type_cast_from_user(value)
+            type_cast_array(value, :type_cast_from_user)
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Array)
+              cast_value_for_database(value)
+            else
+              super
+            end
+          end
+
+          private
+
+          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
+          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
+          end
+
+          ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
+
+          def quote_and_escape(value)
+            case value
+            when ::String
+              if string_requires_quoting?(value)
+                value = value.gsub(/\\/, ARRAY_ESCAPE)
+                value.gsub!(/"/,"\\\"")
+                %("#{value}")
+              else
+                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
+  end
+end

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

@@ -0,0 +1,52 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Bit < Type::Value # :nodoc:
+          def type
+            :bit
+          end
+
+          def type_cast(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
+            end
+          end
+
+          def type_cast_for_database(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/ === value
+            end
+
+            def hex?
+              /\A[0-9A-F]*\Z/i === value
+            end
+
+            protected
+
+            attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class BitVarying < OID::Bit # :nodoc:
+          def type
+            :bit_varying
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Bytea < Type::Binary # :nodoc:
+          def type_cast_from_database(value)
+            return if value.nil?
+            PGconn.unescape_bytea(super)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+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.to_s}\""
+            else
+              "\"#{value.to_s}/#{subnet_mask.to_s(2).count('1')}\""
+            end
+          end
+
+          def type_cast_for_database(value)
+            if IPAddr === value
+              "#{value.to_s}/#{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,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Date < Type::Date # :nodoc:
+          include Infinity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Float < Type::Float # :nodoc:
+          include Infinity
+
+          def cast_value(value)
+            case value
+            when ::Float then     value
+            when 'Infinity' then  ::Float::INFINITY
+            when '-Infinity' then -::Float::INFINITY
+            when 'NaN' then       ::Float::NAN
+            else                  value.to_f
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Hstore < Type::Value # :nodoc:
+          include Type::Mutable
+
+          def type
+            :hstore
+          end
+
+          def type_cast_from_database(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 type_cast_for_database(value)
+            if value.is_a?(::Hash)
+              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
+            else
+              value
+            end
+          end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          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,13 @@
+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/infinity.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        module Infinity # :nodoc:
+          def infinity(options = {})
+            options[:negative] ? -::Float::INFINITY : ::Float::INFINITY
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Integer < Type::Integer # :nodoc:
+          include Infinity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Json < Type::Value # :nodoc:
+          include Type::Mutable
+
+          def type
+            :json
+          end
+
+          def type_cast_from_database(value)
+            if value.is_a?(::String)
+              ::ActiveSupport::JSON.decode(value)
+            else
+              super
+            end
+          end
+
+          def type_cast_for_database(value)
+            if value.is_a?(::Array) || value.is_a?(::Hash)
+              ::ActiveSupport::JSON.encode(value)
+            else
+              super
+            end
+          end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          end
+        end
+      end
+    end
+  end
+end