activerecord-postgres-composite-types 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fab1ca82523eece0cf8b9e0c64fd7cc0903b76ff
-  data.tar.gz: 218877b1a29bce9e891c450b989be9442c223333
+  metadata.gz: 9d4f0647edbf6bedba08366faa187b0920815e9d
+  data.tar.gz: 1256ce07b6c0b404b85f872f316d87e344f327ab
 SHA512:
-  metadata.gz: f98e1e96acfdd9607f918c7db4c47a8f2625ccb0769e8c6a0416008840f24dfec6a136c82aa4c18800d2be6fa8b9c0f3ff1e8b154e9f8e94150b4a5a3103d43b
-  data.tar.gz: df68e9973ecfb0d47906f5a1ac22e3f0bbe0dd7b3b2929c36c2363abbf3d7840df3de8304b0240b6e8513fadf4afdfb772fdacfa8a53f2c5a5ce795dc2de005e
+  metadata.gz: e1c84c2c8a241aebd3412baa37ac3113468d4df82d84a938be27c8863ff6cdb4645c5ca5e841adfde52fbd7db32125e0e919ff55cc2d3df3fa64e3c6d21cb1b3
+  data.tar.gz: 26709a6e15d0b28768228648754654f222074e3ba8a9728e0507ea0bacca0e86998a1d6e539ebe2714888629dc5147f2b90983c6568ef0455a7dcd9a113eca2d

data/Gemfile

@@ -6,13 +6,13 @@ gem 'activerecord', ">= #{AR_VERSION}"
 gem 'pg', '>= 0.17.0'
 
 group :development do
-	gem 'test-unit', '~> 2.1'
-	gem 'shoulda', '>= 0'
-	gem 'rdoc', '~> 3.12'
-	gem 'rake', '~> 10.3'
-	gem 'bundler', '~> 1.0'
-	gem 'jeweler', '~> 2.0.1' unless RUBY_PLATFORM =~ /mswin/
-	gem 'simplecov', '>= 0'
-	gem 'combustion', '~> 0.5.2'
-	gem 'tzinfo-data' if AR_VERSION > '3.2.0'
+  gem 'test-unit', '~> 2.1'
+  gem 'shoulda', '>= 0'
+  gem 'rdoc', '~> 3.12'
+  gem 'rake', '~> 10.3'
+  gem 'bundler', '~> 1.0'
+  gem 'jeweler', '~> 2.0.1' unless RUBY_PLATFORM =~ /mswin/
+  gem 'simplecov', '>= 0'
+  gem 'combustion', '~> 0.5.2'
+  gem 'tzinfo-data' if AR_VERSION > '3.2.0'
 end

data/Rakefile

@@ -12,19 +12,19 @@ end
 require 'rake'
 
 unless RUBY_PLATFORM =~ /mswin/
-	require 'jeweler'
-	Jeweler::Tasks.new do |gem|
-		# gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
-		gem.name = "activerecord-postgres-composite-types"
-		gem.homepage = "http://github.com/puzzleflow/activerecord-postgres-composite-types"
-		gem.license = "MIT"
-		gem.summary = %Q{ActiveRecord composite types support}
-		gem.description = %Q{This gem adds support to the ActiveRecord (3.x and 4.x) for composite types.}
-		gem.email = "rafal.bigaj@puzzleflow.com"
-		gem.authors = ["Rafal Bigaj"]
-		# dependencies defined in Gemfile
-	end
-	Jeweler::RubygemsDotOrgTasks.new
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+    gem.name = "activerecord-postgres-composite-types"
+    gem.homepage = "http://github.com/puzzleflow/activerecord-postgres-composite-types"
+    gem.license = "MIT"
+    gem.summary = %Q{ActiveRecord composite types support}
+    gem.description = %Q{This gem adds support to the ActiveRecord (3.x and 4.x) for composite types.}
+    gem.email = "rafal.bigaj@puzzleflow.com"
+    gem.authors = ["Rafal Bigaj"]
+    # dependencies defined in Gemfile
+  end
+  Jeweler::RubygemsDotOrgTasks.new
 end
 
 require 'rake/testtask'

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.2.5

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.4 ruby lib
+# stub: activerecord-postgres-composite-types 0.2.5 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "activerecord-postgres-composite-types"
-  s.version = "0.2.4"
+  s.version = "0.2.5"
 
   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-11-28"
+  s.date = "2014-12-11"
   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 = [
@@ -45,7 +45,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/puzzleflow/activerecord-postgres-composite-types"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.4.2"
+  s.rubygems_version = "2.4.3"
   s.summary = "ActiveRecord composite types support"
 
   if s.respond_to? :specification_version then

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

@@ -1,10 +1,10 @@
 require 'active_record'
 
 if defined? Rails
-	require "activerecord-postgres-composite-types/railtie"
+  require "activerecord-postgres-composite-types/railtie"
 else
-	ActiveSupport.on_load :active_record do
-		require "activerecord-postgres-composite-types/active_record"
-		require 'postgres_composite_type'
-	end
+  ActiveSupport.on_load :active_record do
+    require "activerecord-postgres-composite-types/active_record"
+    require 'postgres_composite_type'
+  end
 end

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

@@ -5,165 +5,158 @@ require 'activerecord-postgres-composite-types/composite_type_parser'
 
 module ActiveRecord
 
-	module ConnectionAdapters
-
-		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
+  module ConnectionAdapters
+
+    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 }
-				end
-
-				# removes composite type definition (for testing)
-				def unregister_composite_type(type)
-					self.composite_type_classes.delete(type.to_sym)
-					TableDefinition.unregister_composite_type type
-					Table.unregister_composite_type type
-				end
-
-				def composite_type_classes
-					@composite_type_classes ||= {}
-				end
-			end
-		end
-
-		class PostgreSQLColumn < Column
-			# Adds composite type for the column.
-
-			def composite_type_class
-				PostgreSQLAdapter.composite_type_classes[type]
-			end
-
-			def klass_with_composite_types
-				composite_type_klass = PostgreSQLAdapter.composite_type_classes[type]
-				composite_type_klass || klass_without_composite_types
-			end
-
-			alias_method_chain :klass, :composite_types
-
-			def self.string_to_composite_type(klass, string)
-				return string unless String === string
-				if string.present?
-					klass.new(string)
-				end
-			end
-
-			def self.string_to_composite_type(klass, string)
-				return string unless String === string
-				if string.present?
-					fields = CompositeTypeParser.parse_data(string).map.with_index {|val, i| type_cast_composite_type_field(klass, i, val)}
-					klass.new(fields)
-				end
-			end
-
-			def self.type_cast_composite_type_field(klass, i, value)
-				klass.initialize_column_definition
-
-				column = klass.columns[i]
-				raise "Invalid column index: #{i}" unless column
-				cv = column.type_cast(value)
-				if cv.is_a?(String)
-					# unquote
-					cv = cv.upcase == 'NULL' ? nil : cv.gsub(/\A"(.*)"\Z/m) { $1.gsub(/\\(.)/, '\1') }
-				end
-				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
-			end
-
-			alias_method_chain :simplified_type, :composite_types
-		end
-
-		class << TableDefinition
-			# Adds composite type for migrations. So you can add columns to a table like:
-			#   create_table :people do |t|
-			#     ...
-			#     t.composite_type :composite_value
-			#     ...
-			#   end
-			def register_composite_type(composite_type)
-				class_eval <<-RUBY
+          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 }
+        end
+
+        # removes composite type definition (for testing)
+        def unregister_composite_type(type)
+          self.composite_type_classes.delete(type.to_sym)
+          TableDefinition.unregister_composite_type type
+          Table.unregister_composite_type type
+        end
+
+        def composite_type_classes
+          @composite_type_classes ||= {}
+        end
+      end
+    end
+
+    class PostgreSQLColumn < Column
+      # Adds composite type for the column.
+
+      def composite_type_class
+        PostgreSQLAdapter.composite_type_classes[type]
+      end
+
+      def klass_with_composite_types
+        composite_type_klass = PostgreSQLAdapter.composite_type_classes[type]
+        composite_type_klass || klass_without_composite_types
+      end
+
+      alias_method_chain :klass, :composite_types
+
+      def self.string_to_composite_type(klass, string)
+        return string unless String === string
+        if string.present?
+          fields = CompositeTypeParser.parse_data(string).map.with_index { |val, i| type_cast_composite_type_field(klass, i, val) }
+          klass.new(fields)
+        end
+      end
+
+      def self.type_cast_composite_type_field(klass, i, value)
+        klass.initialize_column_definition
+
+        column = klass.columns[i]
+        raise "Invalid column index: #{i}" unless column
+        cv = column.type_cast(value)
+        if cv.is_a?(String)
+          # unquote
+          cv = cv.upcase == 'NULL' ? nil : cv.gsub(/\A"(.*)"\Z/m) { $1.gsub(/\\(.)/, '\1') }
+        end
+        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
+      end
+
+      alias_method_chain :simplified_type, :composite_types
+    end
+
+    class << TableDefinition
+      # Adds composite type for migrations. So you can add columns to a table like:
+      #   create_table :people do |t|
+      #     ...
+      #     t.composite_type :composite_value
+      #     ...
+      #   end
+      def register_composite_type(composite_type)
+        class_eval <<-RUBY
+          def #{composite_type}(*args)
+            options = args.extract_options!
+            column_names = args
+            column_names.each { |name| column(name, '#{composite_type}', options) }
+          end
+        RUBY
+      end
+
+      # Removes composite types from migrations (for testing)
+      def unregister_composite_type(composite_type)
+        remove_method composite_type
+      end
+    end
+
+    class << Table
+
+      # Adds composite type for migrations. So you can add columns to a table like:
+      #   change_table :people do |t|
+      #     ...
+      #     t.composite_type :composite_value
+      #     ...
+      #   end
+      def register_composite_type(composite_type)
+        class_eval <<-RUBY
 					def #{composite_type}(*args)
 						options = args.extract_options!
 						column_names = args
 						column_names.each { |name| column(name, '#{composite_type}', options) }
 					end
-				RUBY
-			end
-
-			# Removes composite types from migrations (for testing)
-			def unregister_composite_type(composite_type)
-				remove_method composite_type
-			end
-		end
-
-		class << Table
-
-			# Adds composite type for migrations. So you can add columns to a table like:
-			#   change_table :people do |t|
-			#     ...
-			#     t.composite_type :composite_value
-			#     ...
-			#   end
-			def register_composite_type(composite_type)
-				class_eval <<-RUBY
-					def #{composite_type}(*args)
-						options = args.extract_options!
-						column_names = args
-						column_names.each { |name| column(name, '#{composite_type}', options) }
-					end
-				RUBY
-			end
+        RUBY
+      end
 
-			# Removes composite types from migrations (for testing)
-			def unregister_composite_type(composite_type)
-				remove_method composite_type
-			end
+      # Removes composite types from migrations (for testing)
+      def unregister_composite_type(composite_type)
+        remove_method composite_type
+      end
 
-		end
+    end
 
-	end
+  end
 
 end
 

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

@@ -1,104 +1,104 @@
 # ActiveRecord 3.X specific extensions.
 module ActiveRecord
 
-	module ConnectionAdapters
+  module ConnectionAdapters
 
-		class PostgreSQLAdapter
-			# 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
-							value = klass.new(value)
-							PostgreSQLColumn.composite_type_to_string(value, self)
-						else
-							type_cast_without_composite_types(value, column)
-						end
-					else
-						type_cast_without_composite_types(value, column)
-				end
-			end
+    class PostgreSQLAdapter
+      # 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
+              value = klass.new(value)
+              PostgreSQLColumn.composite_type_to_string(value, self)
+            else
+              type_cast_without_composite_types(value, column)
+            end
+          else
+            type_cast_without_composite_types(value, column)
+        end
+      end
 
-			alias_method_chain :type_cast, :composite_types
-		end
+      alias_method_chain :type_cast, :composite_types
+    end
 
-		class PostgreSQLColumn < Column
-			# Adds composite type for the column.
+    class PostgreSQLColumn < Column
+      # Adds composite type for the column.
 
-			# 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]
-					self.class.string_to_composite_type(composite_type_klass, value)
-				else
-					type_cast_without_composite_types(value)
-				end
-			end
+      # 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]
+          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
+      alias_method_chain :type_cast, :composite_types
 
-			# quote_and_escape - Rails 4 code
+      # quote_and_escape - Rails 4 code
 
-			ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
+      ARRAY_ESCAPE = "\\" * 2 * 2 # escape the backslash twice for PG arrays
 
-			def self.quote_and_escape(value)
-				case value
-					when "NULL", Numeric
-						value
-					else
-						value = value.gsub(/\\/, ARRAY_ESCAPE)
-						value.gsub!(/"/, "\\\"")
-						"\"#{value}\""
-				end
-			end
+      def self.quote_and_escape(value)
+        case value
+          when "NULL", Numeric
+            value
+          else
+            value = value.gsub(/\\/, ARRAY_ESCAPE)
+            value.gsub!(/"/, "\\\"")
+            "\"#{value}\""
+        end
+      end
 
-			def self.composite_type_to_string(object, adapter)
-				quoted_values = object.class.columns.collect do |column|
-					value = object.send(column.name)
-					if String === value
-						if value == "NULL"
-							"\"#{value}\""
-						else
-							quote_and_escape(adapter.type_cast(value, column))
-						end
-					else
-						adapter.type_cast(value, column)
-					end
-				end
-				"(#{quoted_values.join(',')})"
-			end
+      def self.composite_type_to_string(object, adapter)
+        quoted_values = object.class.columns.collect do |column|
+          value = object.send(column.name)
+          if String === value
+            if value == "NULL"
+              "\"#{value}\""
+            else
+              quote_and_escape(adapter.type_cast(value, column))
+            end
+          else
+            adapter.type_cast(value, column)
+          end
+        end
+        "(#{quoted_values.join(',')})"
+      end
 
-			def type_cast_code_with_composite_types(var_name)
-				if composite_type_klass = PostgreSQLAdapter.composite_type_classes[type]
-					"#{self.class}.string_to_composite_type(#{composite_type_klass}, #{var_name})"
-				else
-					type_cast_code_without_composite_types(var_name)
-				end
-			end
+      def type_cast_code_with_composite_types(var_name)
+        if composite_type_klass = PostgreSQLAdapter.composite_type_classes[type]
+          "#{self.class}.string_to_composite_type(#{composite_type_klass}, #{var_name})"
+        else
+          type_cast_code_without_composite_types(var_name)
+        end
+      end
 
-			alias_method_chain :type_cast_code, :composite_types
-		end
-	end
+      alias_method_chain :type_cast_code, :composite_types
+    end
+  end
 
-	module AttributeMethods
-		module CompositeTypes
-			extend ActiveSupport::Concern
+  module AttributeMethods
+    module CompositeTypes
+      extend ActiveSupport::Concern
 
-			def type_cast_attribute_for_write(column, value)
-				if column && klass = column.composite_type_class
-					# Cast Hash and Array to composite type klass
-					if value.is_a?(klass)
-						value
-					else
-						klass.new(value)
-					end
-				else
-					super(column, value)
-				end
-			end
-		end
-	end
+      def type_cast_attribute_for_write(column, value)
+        if column && klass = column.composite_type_class
+          # Cast Hash and Array to composite type klass
+          if value.is_a?(klass)
+            value
+          else
+            klass.new(value)
+          end
+        else
+          super(column, value)
+        end
+      end
+    end
+  end
 
-	Base.send :include, AttributeMethods::CompositeTypes
+  Base.send :include, AttributeMethods::CompositeTypes
 end