activerecord-postgres-composite-types 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d4f0647edbf6bedba08366faa187b0920815e9d
-  data.tar.gz: 1256ce07b6c0b404b85f872f316d87e344f327ab
+  metadata.gz: 147af26bcacdef7cd83aa2c4bb67dad6b0b6747f
+  data.tar.gz: 4f8e376d697804a4be2e04d3931047b1922b92ac
 SHA512:
-  metadata.gz: e1c84c2c8a241aebd3412baa37ac3113468d4df82d84a938be27c8863ff6cdb4645c5ca5e841adfde52fbd7db32125e0e919ff55cc2d3df3fa64e3c6d21cb1b3
-  data.tar.gz: 26709a6e15d0b28768228648754654f222074e3ba8a9728e0507ea0bacca0e86998a1d6e539ebe2714888629dc5147f2b90983c6568ef0455a7dcd9a113eca2d
+  metadata.gz: 7a503873a92e2c34cd620e52b1526a006910ecaa1a9b3ade3ab0498ecc771118eb3d9353cf2dd7df965895f41a6a8016388506194474e29a972cb762f11c196c
+  data.tar.gz: 47e52eda590974f4b530428313145ca0d8d210059e2a1bbd98d23e4bd817ae27e54dccf5aa7e2da592175751eec9834a154836caadee839cdae06eb94914f81c

data/.travis.yml

@@ -1,6 +1,10 @@
 language: ruby
 rvm:
   - 2.1.0
+env:
+  - AR_VERSION=3.2.0
+  - AR_VERSION=4.1.9
+  - AR_VERSION=4.2.0
 addons:
   postgresql: "9.3"
 before_script:

data/Gemfile

@@ -1,8 +1,8 @@
 source 'http://rubygems.org'
 
-AR_VERSION = '3.2.0'
+AR_VERSION = ENV['AR_VERSION'] || '3.2.0'
 
-gem 'activerecord', ">= #{AR_VERSION}"
+gem 'activerecord', AR_VERSION
 gem 'pg', '>= 0.17.0'
 
 group :development do

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.2.6

data/activerecord-postgres-composite-types.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: activerecord-postgres-composite-types 0.2.5 ruby lib
+# stub: activerecord-postgres-composite-types 0.2.6 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "activerecord-postgres-composite-types"
-  s.version = "0.2.5"
+  s.version = "0.2.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Rafal Bigaj"]
-  s.date = "2014-12-11"
+  s.date = "2015-03-20"
   s.description = "This gem adds support to the ActiveRecord (3.x and 4.x) for composite types."
   s.email = "rafal.bigaj@puzzleflow.com"
   s.extra_rdoc_files = [
@@ -29,9 +29,12 @@ Gem::Specification.new do |s|
     "activerecord-postgres-composite-types.gemspec",
     "lib/activerecord-postgres-composite-types.rb",
     "lib/activerecord-postgres-composite-types/active_record.rb",
-    "lib/activerecord-postgres-composite-types/active_record_3.rb",
-    "lib/activerecord-postgres-composite-types/active_record_4.rb",
+    "lib/activerecord-postgres-composite-types/active_record_3_2.rb",
+    "lib/activerecord-postgres-composite-types/active_record_4_1.rb",
+    "lib/activerecord-postgres-composite-types/active_record_4_2.rb",
     "lib/activerecord-postgres-composite-types/composite_type_parser.rb",
+    "lib/activerecord-postgres-composite-types/oid/composite_type_4_1.rb",
+    "lib/activerecord-postgres-composite-types/oid/composite_type_4_2.rb",
     "lib/activerecord-postgres-composite-types/railtie.rb",
     "lib/postgres_composite_type.rb",
     "test/composite_types.rb",
@@ -45,14 +48,14 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/puzzleflow/activerecord-postgres-composite-types"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.4.3"
+  s.rubygems_version = "2.4.5"
   s.summary = "ActiveRecord composite types support"
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 3.2.0"])
+      s.add_runtime_dependency(%q<activerecord>, ["= 4.1.9"])
       s.add_runtime_dependency(%q<pg>, [">= 0.17.0"])
       s.add_development_dependency(%q<test-unit>, ["~> 2.1"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
@@ -62,8 +65,9 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<combustion>, ["~> 0.5.2"])
+      s.add_development_dependency(%q<tzinfo-data>, [">= 0"])
     else
-      s.add_dependency(%q<activerecord>, [">= 3.2.0"])
+      s.add_dependency(%q<activerecord>, ["= 4.1.9"])
       s.add_dependency(%q<pg>, [">= 0.17.0"])
       s.add_dependency(%q<test-unit>, ["~> 2.1"])
       s.add_dependency(%q<shoulda>, [">= 0"])
@@ -73,9 +77,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<combustion>, ["~> 0.5.2"])
+      s.add_dependency(%q<tzinfo-data>, [">= 0"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 3.2.0"])
+    s.add_dependency(%q<activerecord>, ["= 4.1.9"])
     s.add_dependency(%q<pg>, [">= 0.17.0"])
     s.add_dependency(%q<test-unit>, ["~> 2.1"])
     s.add_dependency(%q<shoulda>, [">= 0"])
@@ -85,6 +90,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<combustion>, ["~> 0.5.2"])
+    s.add_dependency(%q<tzinfo-data>, [">= 0"])
   end
 end
 

data/lib/activerecord-postgres-composite-types/active_record.rb

@@ -9,38 +9,14 @@ module ActiveRecord
 
     class PostgreSQLAdapter
 
-      # Quotes the column value to help prevent {SQL injection attacks}
-      def quote_with_composite_types(value, column = nil)
-        if value.class < PostgresCompositeType
-          "'#{PostgreSQLColumn.composite_type_to_string(value, self).gsub(/'/, "''")}'"
-        else
-          quote_without_composite_types(value, column)
-        end
-      end
-
-      alias_method_chain :quote, :composite_types
-
       class << self
         def register_composite_type_class(klass)
           self.composite_type_classes[klass.type] = klass
           TableDefinition.register_composite_type klass.type
           Table.register_composite_type klass.type
-          register_arel_visitor klass
           register_oid_type klass
         end
 
-        def register_arel_visitor(klass)
-          Arel::Visitors::Visitor.class_eval <<-RUBY
-						def visit_#{klass.name.gsub('::', '_')}(o, a=nil)
-              "'" + ActiveRecord::ConnectionAdapters::PostgreSQLColumn::composite_type_to_string(o, o.class.connection) + "'" + '::#{klass.type}'
-						end
-          RUBY
-        end
-
-        def register_oid_type(klass)
-          # only AR 4.X
-        end
-
         # removes composite types definition (for testing)
         def unregister_composite_types(*composite_types)
           composite_types.each { |type| unregister_composite_type type }
@@ -86,7 +62,8 @@ module ActiveRecord
 
         column = klass.columns[i]
         raise "Invalid column index: #{i}" unless column
-        cv = column.type_cast(value)
+
+        cv = column.type_cast_from_database(value)
         if cv.is_a?(String)
           # unquote
           cv = cv.upcase == 'NULL' ? nil : cv.gsub(/\A"(.*)"\Z/m) { $1.gsub(/\\(.)/, '\1') }
@@ -94,18 +71,24 @@ module ActiveRecord
         cv
       end
 
-      private
-
-      def simplified_type_with_composite_types(field_type)
-        type = field_type.to_sym
-        if PostgreSQLAdapter.composite_type_classes.has_key?(type)
-          type
-        else
-          simplified_type_without_composite_types(field_type)
-        end
+      unless method_defined?(:type_cast_from_database) # AR ver < 4.2
+				alias_method :type_cast_from_database, :type_cast
       end
 
-      alias_method_chain :simplified_type, :composite_types
+      private
+
+       if private_method_defined?(:simplified_type) # up to v4.1
+ 	      def simplified_type_with_composite_types(field_type)
+ 	        type = field_type.to_sym
+ 	        if PostgreSQLAdapter.composite_type_classes.has_key?(type)
+ 	          type
+ 	        else
+ 	          simplified_type_without_composite_types(field_type)
+ 	        end
+ 	      end
+
+ 	      alias_method_chain :simplified_type, :composite_types
+       end
     end
 
     class << TableDefinition
@@ -160,4 +143,8 @@ module ActiveRecord
 
 end
 
-require_relative "active_record_#{ActiveRecord::VERSION::MAJOR}"
+begin
+	require_relative "active_record_#{ActiveRecord::VERSION::STRING[0..2].sub('.', '_')}"
+rescue LoadError
+	raise "Unsupported ActiveRecord version: #{ActiveRecord::VERSION::STRING}"
+end

data/lib/activerecord-postgres-composite-types/{active_record_3.rb → active_record_3_2.rb}

@@ -4,24 +4,43 @@ module ActiveRecord
   module ConnectionAdapters
 
     class PostgreSQLAdapter
-      # Cast a +value+ to a type that the database understands.
+	    # Quotes the column value to help prevent {SQL injection attacks}
+	    def quote_with_composite_types(value, column = nil)
+		    if value.class < PostgresCompositeType
+			    "'#{PostgreSQLColumn.composite_type_to_string(value, self).gsub(/'/, "''")}'"
+		    else
+			    quote_without_composite_types(value, column)
+		    end
+	    end
+	    alias_method_chain :quote, :composite_types
+
+	    # Cast a +value+ to a type that the database understands.
       def type_cast_with_composite_types(value, column)
         case value
           when PostgresCompositeType
             PostgreSQLColumn.composite_type_to_string(value, self)
           when Array, Hash
-            if klass = column.composite_type_class
+            if (klass = column.composite_type_class)
               value = klass.new(value)
               PostgreSQLColumn.composite_type_to_string(value, self)
             else
               type_cast_without_composite_types(value, column)
             end
-          else
+	        else
             type_cast_without_composite_types(value, column)
         end
       end
-
       alias_method_chain :type_cast, :composite_types
+
+			class << self
+				def register_oid_type(klass)
+					Arel::Visitors::Visitor.module_eval <<-RUBY, __FILE__, __LINE__
+						def visit_#{klass.name.gsub('::', '_')}(o, a=nil)
+							o.quoted_value
+						end
+					RUBY
+				end
+			end
     end
 
     class PostgreSQLColumn < Column
@@ -29,13 +48,12 @@ module ActiveRecord
 
       # Casts value (which is a String) to an appropriate instance.
       def type_cast_with_composite_types(value)
-        if composite_type_klass = PostgreSQLAdapter.composite_type_classes[type]
+        if (composite_type_klass = PostgreSQLAdapter.composite_type_classes[type])
           self.class.string_to_composite_type(composite_type_klass, value)
         else
           type_cast_without_composite_types(value)
         end
       end
-
       alias_method_chain :type_cast, :composite_types
 
       # quote_and_escape - Rails 4 code
@@ -63,7 +81,12 @@ module ActiveRecord
               quote_and_escape(adapter.type_cast(value, column))
             end
           else
-            adapter.type_cast(value, column)
+	          res = adapter.type_cast(value, column)
+	          if value.class < PostgresCompositeType
+		          quote_and_escape(res)
+	          else
+		          res
+	          end
           end
         end
         "(#{quoted_values.join(',')})"
@@ -86,7 +109,7 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       def type_cast_attribute_for_write(column, value)
-        if column && klass = column.composite_type_class
+        if column && !value.nil? && (klass = column.composite_type_class)
           # Cast Hash and Array to composite type klass
           if value.is_a?(klass)
             value

data/lib/activerecord-postgres-composite-types/{active_record_4.rb → active_record_4_1.rb}

@@ -1,33 +1,12 @@
-# ActiveRecord 3.X specific extensions.
+# ActiveRecord 4.0, 4.1 specific extensions.
+
+require_relative 'oid/composite_type_4_1'
+
 module ActiveRecord
 
   module ConnectionAdapters
 
     class PostgreSQLAdapter
-      module OID
-        class CompositeType < Type
-          def initialize(composite_type_class)
-            @composite_type_class = composite_type_class
-          end
-
-          # Casts value (which is a String) to an appropriate instance.
-          def type_cast(value)
-            PostgreSQLColumn.string_to_composite_type(@composite_type_class, value)
-            # @composite_type_class.new(value)
-          end
-
-          # Casts a Ruby value to something appropriate for writing to the database.
-          def type_cast_for_write(value)
-            # Cast Hash and Array to composite type klass
-            if value.is_a?(@composite_type_class)
-              value
-            else
-              @composite_type_class.new(value)
-            end
-          end
-        end
-      end
-
       class << self
         def register_oid_type(klass)
           OID.register_type klass.type.to_s, OID::CompositeType.new(klass)
@@ -36,18 +15,15 @@ module ActiveRecord
         end
       end
 
-      def add_composite_type_to_map(type)
-        oid_type = OID::NAMES[type.to_s]
-        raise "OID type: '#{type}' not registered" unless oid_type
-
-        result = execute("SELECT oid, typname, typelem, typdelim, typinput FROM pg_type WHERE typname = '#{type}'", 'SCHEMA')
-        raise "Composite type: '#{type}' not defined in PostgreSQL database" if result.empty?
-        row = result[0]
-
-        unless type_map.key? row['typelem'].to_i
-          type_map[row['oid'].to_i] = vector
-        end
+      # Quotes the column value to help prevent {SQL injection attacks}
+      def quote_with_composite_types(value, column = nil)
+	      if value.class < PostgresCompositeType
+		      "'#{PostgreSQLColumn.composite_type_to_string(value, self).gsub(/'/, "''")}'"
+	      else
+		      quote_without_composite_types(value, column)
+	      end
       end
+      alias_method_chain :quote, :composite_types
 
       # Cast a +value+ to a type that the database understands.
       def type_cast_with_composite_types(value, column, array_member = false)

data/lib/activerecord-postgres-composite-types/active_record_4_2.rb

@@ -0,0 +1,38 @@
+# ActiveRecord 4.2 specific extensions.
+
+require_relative 'oid/composite_type_4_2'
+
+module ActiveRecord
+
+	module ConnectionAdapters
+
+    class PostgreSQLAdapter
+
+	    class << self
+				mattr_accessor :ordered_composite_type_classes
+				self.ordered_composite_type_classes = []
+
+        def register_oid_type(klass)
+	        self.ordered_composite_type_classes << klass
+          # Dirty. Only this type should be added to type map
+	        klass.connection.send(:reload_type_map) if klass.connected?
+        end
+      end
+
+      # Rails 4.2
+      def initialize_type_map_with_composite_types(m)
+	      initialize_type_map_without_composite_types(m)
+	      self.class.ordered_composite_type_classes.each do |klass|
+		      m.register_type klass.type.to_s, OID::CompositeType.new(klass)
+	      end
+      end
+      alias_method_chain :initialize_type_map, :composite_types
+    end
+
+    class PostgreSQLColumn < Column
+      def self.composite_type_to_string(object, adapter)
+				PostgreSQL::OID::CompositeType.new(object.class).type_cast_for_database(object)
+      end
+    end
+  end
+end

data/lib/activerecord-postgres-composite-types/oid/composite_type_4_1.rb

@@ -0,0 +1,29 @@
+module ActiveRecord
+	module ConnectionAdapters
+		class PostgreSQLAdapter
+			module OID
+				class CompositeType < Type
+					def initialize(composite_type_class)
+						@composite_type_class = composite_type_class
+					end
+
+					# Casts value (which is a String) to an appropriate instance.
+					def type_cast(value)
+						PostgreSQLColumn.string_to_composite_type(@composite_type_class, value)
+						# @composite_type_class.new(value)
+					end
+
+					# Casts a Ruby value to something appropriate for writing to the database.
+					def type_cast_for_write(value)
+						# Cast Hash and Array to composite type klass
+						if value.is_a?(@composite_type_class) || value.nil?
+							value
+						else
+							@composite_type_class.new(value)
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/activerecord-postgres-composite-types/oid/composite_type_4_2.rb

@@ -0,0 +1,60 @@
+module ActiveRecord
+	module ConnectionAdapters
+		module PostgreSQL
+			module OID
+				class CompositeType < OID::Array
+
+					def initialize(composite_type_class)
+						@composite_type_class = composite_type_class
+						@delimiter = ','
+					end
+
+					def type
+						@composite_type_class.type
+					end
+
+					def type_cast_from_database(value)
+						PostgreSQLColumn.string_to_composite_type(@composite_type_class, value)
+					end
+
+					def type_cast_from_user(value)
+						if value.is_a?(@composite_type_class) || value.nil?
+							value
+						else
+							@composite_type_class.new(value)
+						end
+					end
+
+
+					def type_cast_for_database(object)
+						return object if object.is_a?(String) # already quoted by AREL visitor
+						return "NULL" if object == nil
+						quoted_values = object.class.columns.collect do |column|
+							value = object.send(column.name)
+							if String === value
+								quote_and_escape(column.type_cast_for_database(value))
+							else
+								res = column.type_cast_for_database(value)
+								if value.class < PostgresCompositeType
+									quote_and_escape(res)
+								else
+									res
+								end
+							end
+						end
+						"(#{quoted_values.join(',')})"
+					end
+
+					# Overwrite OID::Array method - regular brackets () instead of {} have to be escaped
+					def string_requires_quoting?(string)
+						string.empty? ||
+								string == "NULL" ||
+								string =~ /[\(\)"\\\s]/ ||
+								string.include?(delimiter)
+					end
+
+				end
+			end
+		end
+	end
+end

data/lib/postgres_composite_type.rb

@@ -50,14 +50,18 @@ class PostgresCompositeType
     def initialize_column_definition
       unless @columns
         @columns = self.connection.columns(type)
-        attr_accessor *@columns.map(&:name)
+        attr_reader *@columns.map(&:name)
+        @columns.each do |column|
+	        define_method("#{column.name}=") do |value|
+		        instance_variable_set "@#{column.name}", type_cast_field_from_user(column, value)
+	        end
+        end
       end
     end
   end
 
   def initialize(value)
     self.class.initialize_column_definition
-
     case value
       when String
         ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_composite_type(self.class, value)
@@ -80,14 +84,45 @@ class PostgresCompositeType
     0
   end
 
+  # Used for AREL eq node
+  def quoted_value
+	  "'" + ActiveRecord::ConnectionAdapters::PostgreSQLColumn::composite_type_to_string(self, self.class.connection) + "'::#{self.class.type}"
+  end
+
   private
 
+	if ActiveRecord::ConnectionAdapters::PostgreSQLColumn.method_defined?(:type_cast_from_user) # v4.2 and later
+	  def type_cast_field_from_user(column, value)
+		  column.type_cast_from_user(value)
+	  end
+	elsif ActiveRecord::ConnectionAdapters::PostgreSQLColumn.method_defined?(:type_cast_for_write) # v4.0 and v4.1
+		def type_cast_field_from_user(column, value)
+			column.type_cast_for_write(value)
+		end
+	else # v3.X
+		def type_cast_field_from_user(column, value)
+			klass = column.composite_type_class
+			if klass
+				case value
+					when Hash, Array
+						klass.new(value)
+					when String
+						ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_composite_type(klass, value)
+					else
+						value
+				end
+			else
+				value
+			end
+		end
+	end
+
   def set_attributes(values)
     values.each do |name, value|
-      if Hash === value || Array === value
-        klass = self.class.columns.find(name).first.try(:composite_type_class)
-        value = klass.new(value) if klass
-      end
+      #if Hash === value || Array === value
+      #  klass = self.class.columns.find(name).first.try(:composite_type_class)
+      #  value = klass.new(value) if klass
+      #end
       send "#{name}=", value
     end
   end
@@ -95,12 +130,16 @@ class PostgresCompositeType
   def set_values(values)
     raise "Invalid values count: #{values.size}, expected: #{self.class.columns.size}" if values.size != self.class.columns.size
     self.class.columns.each.with_index do |column, i|
-      if Hash === values[i] || Array === values[i]
-        klass = column.composite_type_class
-        values[i] = klass.new(values[i]) if klass
-      end
+      #if Hash === values[i] || Array === values[i]
+      #  klass = column.composite_type_class
+      #  values[i] = klass.new(values[i]) if klass
+      #end
       send "#{column.name}=", values[i]
     end
   end
 
+  ActiveRecord::PredicateBuilder.register_handler(PostgresCompositeType, ->(attribute, value) {
+	  quoted = Arel::Nodes::SqlLiteral.new(value.quoted_value)
+	  Arel::Nodes::Equality.new(attribute, quoted)
+  }) if ActiveRecord::PredicateBuilder.respond_to?(:register_handler) # v.4.X
 end

data/test/composite_types.rb

@@ -1,6 +1,6 @@
 require 'postgres_composite_type'
 
-if ActiveRecord::VERSION::MAJOR > 3
+if ActiveRecord::VERSION::MAJOR > 3 && ActiveRecord::VERSION::MINOR < 2 # v4.0 & v4.1
   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID.alias_type 'rgb_color', 'text'
 end
 

data/test/helper.rb

@@ -24,6 +24,8 @@ rescue Bundler::BundlerError => e
   exit e.status_code
 end
 
+require 'shoulda'
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
@@ -36,6 +38,8 @@ end
 Combustion.path = 'test/internal'
 Combustion.initialize! :active_record
 
+ActiveRecord::Base.default_timezone = :utc
+
 class Test::Unit::TestCase
   def connection
     ActiveRecord::Base.connection

data/test/internal/db/schema.rb

@@ -7,6 +7,10 @@ ActiveRecord::Schema.define do
   execute "CREATE TYPE nested_type AS (comp compfoo, color rgb_color)"
   execute "CREATE TYPE nested_nested_type AS (nested nested_type, color rgb_color)"
 
+  create_table :my_table, :id => false do |t|
+    t.column :value, :my_type
+  end
+
   create_table :foos, :id => false do |t|
     t.column :comp, :compfoo, default: "(0,\"\")"
   end
@@ -22,3 +26,5 @@ ActiveRecord::Schema.define do
   execute "INSERT INTO foos VALUES ((0,'abc')), ((1,'a/b''c\\d e f'))"
   execute "INSERT INTO bars VALUES (((0,'abc'),'red')), (((1,'cba'),'blue'))"
 end
+
+ActiveRecord::Base.connection.send(:reload_type_map) rescue nil # only v4.X

data/test/test_composite_type_class.rb

@@ -4,6 +4,10 @@ class TestCompositeTypeClass < Test::Unit::TestCase
 
   PostgreSQLColumn = ActiveRecord::ConnectionAdapters::PostgreSQLColumn
 
+  setup do
+	  @my_type_column = connection.columns(:my_table).first
+  end
+
   should "define accessors" do
     assert MyType.method_defined?(:name)
     assert MyType.method_defined?(:name=)
@@ -36,7 +40,8 @@ class TestCompositeTypeClass < Test::Unit::TestCase
 
   should "cast to qouted string" do
     value = MyType.new(number: 1, name: '"\'a\'bc[]*/\"', date: Time.parse('2014-08-27 12:00:00 UTC'))
-    assert_equal %Q{'("\\\"''a''bc[]*/\\\\\\\"",1,2014-08-27 12:00:00.000000)'}, connection.quote(value)
+    quoted = connection.quote(value, @my_type_column).sub(':00.000000', ':00 UTC') # On AR ver < 4.2 time is quoted to format with milliseconds
+    assert_equal %Q{'("\\\"''a''bc[]*/\\\\\\\"",1,2014-08-27 12:00:00 UTC)'}, quoted
   end
 
   should "parse string and return array" do

data/test/test_nested_types.rb

@@ -46,19 +46,19 @@ class TestNestedTypes < Test::Unit::TestCase
   end
 
   should "parser should work when nested attribute contains parenthesis" do
-    bar = Bar2.create!(nested: {nested: {comp: [1, 'dc)))a'], color: 'blue'}, color: 'red'})
-    Bar2.all.to_a.last.nested
-    assert true
+    Bar2.create!(nested: {nested: {comp: [1, 'dc)))a'], color: 'blue'}, color: 'red'})
+    assert_equal 'dc)))a', Bar2.all.to_a.last.nested.nested.comp.f2
+	  assert Bar2.where(nested: NestedNestedType.new(nested: {comp: [1, 'dc)))a'], color: 'blue'}, color: 'red')).exists?
   end
 
   should "parser should work when nested attribute contains double quote" do
-    bar = Bar2.create!(nested: {nested: {comp: [1, "dc\"a"], color: 'blue'}, color: 'blue'})
+    Bar2.create!(nested: {nested: {comp: [1, "dc\"a"], color: 'blue'}, color: 'blue'})
     assert_equal 'blue', Bar2.all.to_a.last.nested.color
     assert_equal 'dc"a', Bar2.all.to_a.last.nested.nested.comp.f2
   end
 
   should "parser should work when nested attribute contains backslash" do
-    bar = Bar2.create!(nested: {nested: {comp: [1, "dc\\a"], color: 'blue'}, color: 'green'})
+    Bar2.create!(nested: {nested: {comp: [1, "dc\\a"], color: 'blue'}, color: 'green'})
     assert_equal 'green', Bar2.all.to_a.last.nested.color
     assert_equal 'dc\\a', Bar2.all.to_a.last.nested.nested.comp.f2
   end

data/test/test_postgres_composite_types.rb

@@ -45,4 +45,11 @@ class TestPostgresCompositeTypes < Test::Unit::TestCase
     assert_equal 'text 3', foo.comp.f2
     assert Foo.where(comp: Compfoo.new({f1: 111, f2: 'text 3'})).exists?
   end
+
+  should 'make object nil' do
+    foo = Foo.create!(comp: [333, 'ala ma kota'])
+    foo.comp = nil
+
+    assert_nil foo.comp
+  end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgres-composite-types
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Rafal Bigaj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-11 00:00:00.000000000 Z
+date: 2015-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.1.9
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This gem adds support to the ActiveRecord (3.x and 4.x) for composite
   types.
 email: rafal.bigaj@puzzleflow.com
@@ -169,9 +183,12 @@ files:
 - activerecord-postgres-composite-types.gemspec
 - lib/activerecord-postgres-composite-types.rb
 - lib/activerecord-postgres-composite-types/active_record.rb
-- lib/activerecord-postgres-composite-types/active_record_3.rb
-- lib/activerecord-postgres-composite-types/active_record_4.rb
+- lib/activerecord-postgres-composite-types/active_record_3_2.rb
+- lib/activerecord-postgres-composite-types/active_record_4_1.rb
+- lib/activerecord-postgres-composite-types/active_record_4_2.rb
 - lib/activerecord-postgres-composite-types/composite_type_parser.rb
+- lib/activerecord-postgres-composite-types/oid/composite_type_4_1.rb
+- lib/activerecord-postgres-composite-types/oid/composite_type_4_2.rb
 - lib/activerecord-postgres-composite-types/railtie.rb
 - lib/postgres_composite_type.rb
 - test/composite_types.rb
@@ -202,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: ActiveRecord composite types support