activerecord-postgres-composite-types 0.2.4 → 0.2.5

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

@@ -1,108 +1,108 @@
 # ActiveRecord 3.X specific extensions.
 module ActiveRecord
 
-	module ConnectionAdapters
+  module ConnectionAdapters
 
-		class PostgreSQLAdapter
-			module OID
-				class CompositeType < Type
-					def initialize(composite_type_class)
-						@composite_type_class = composite_type_class
-					end
+    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 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
+          # 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)
-					# Dirty. Only this type should be added to type map
-					klass.connection.send(:reload_type_map) if klass.connected?
-				end
-			end
+      class << self
+        def register_oid_type(klass)
+          OID.register_type klass.type.to_s, OID::CompositeType.new(klass)
+          # Dirty. Only this type should be added to type map
+          klass.connection.send(:reload_type_map) if klass.connected?
+        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
+      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]
+        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
-			end
+        unless type_map.key? row['typelem'].to_i
+          type_map[row['oid'].to_i] = vector
+        end
+      end
 
-			# Cast a +value+ to a type that the database understands.
-			def type_cast_with_composite_types(value, column, array_member = false)
-				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, array_member)
-						end
-					else
-						type_cast_without_composite_types(value, column, array_member)
-				end
-			end
+      # Cast a +value+ to a type that the database understands.
+      def type_cast_with_composite_types(value, column, array_member = false)
+        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, array_member)
+            end
+          else
+            type_cast_without_composite_types(value, column, array_member)
+        end
+      end
 
-			alias_method_chain :type_cast, :composite_types
-		end
+      alias_method_chain :type_cast, :composite_types
+    end
 
-		class PostgreSQLColumn < 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
+    class PostgreSQLColumn < 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
 
-			alias_method_chain :type_cast, :composite_types
+      alias_method_chain :type_cast, :composite_types
 
-			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, true))
-						end
-					else
-						res = adapter.type_cast(value, column, true)
-						if value.class < PostgresCompositeType
-							quote_and_escape(res)
-						else
-							res
-						end
-					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, true))
+            end
+          else
+            res = adapter.type_cast(value, column, true)
+            if value.class < PostgresCompositeType
+              quote_and_escape(res)
+            else
+              res
+            end
+          end
+        end
+        "(#{quoted_values.join(',')})"
+      end
 
 
-		end
-	end
+    end
+  end
 end

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

@@ -1,95 +1,46 @@
 module ActiveRecord
-	module ConnectionAdapters
-		class PostgreSQLColumn
-			class CompositeTypeParser
-				DOUBLE_QUOTE = '"'
-				BACKSLASH = "\\"
-				COMMA = ','
-				BRACKET_OPEN = '('
-				BRACKET_CLOSE = ')'
-
-				def self.parse_data(string)
-					new.parse_data(string)
-				end
-
-				def parse_data(string)
-					local_index = 0
-					array = []
-					while (local_index < string.length)
-						case string[local_index]
-							when BRACKET_OPEN
-								local_index, array = parse_composite_type_contents(array, string, local_index + 1)
-							when BRACKET_CLOSE
-								return array
-						end
-						local_index += 1
-					end
-
-					array
-				end
-
-				private
-				def parse_composite_type_contents(array, string, index)
-					is_escaping = false
-					is_quoted = false
-					was_quoted = false
-					current_item = ''
-
-					local_index = index
-					while local_index
-						token = string[local_index]
-						if is_escaping
-							current_item << token
-							is_escaping = false
-						else
-							if is_quoted
-								case token
-									when DOUBLE_QUOTE
-										is_quoted = false
-										was_quoted = true
-									when BACKSLASH
-										is_escaping = true
-									else
-										current_item << token
-								end
-							else
-								case token
-									when BACKSLASH
-										is_escaping = true
-									when COMMA
-										add_item_to_array(array, current_item, was_quoted)
-										current_item = ''
-										was_quoted = false
-									when DOUBLE_QUOTE
-										is_quoted = true
-									when BRACKET_OPEN
-										internal_items = []
-										local_index, internal_items = parse_composite_type_contents(internal_items, string, local_index + 1)
-										array.push(internal_items)
-									when BRACKET_CLOSE
-										add_item_to_array(array, current_item, was_quoted)
-										return local_index, array
-									else
-										current_item << token
-								end
-							end
-						end
-
-						local_index += 1
-					end
-					return local_index, array
-				end
-
-				def add_item_to_array(array, current_item, quoted)
-					return if !quoted && current_item.length == 0
-
-					if !quoted && current_item == 'NULL'
-						array.push nil
-					else
-						array.push current_item
-					end
-				end
-			end
-		end
-	end
+  module ConnectionAdapters
+    class PostgreSQLColumn
+      class CompositeTypeParser
+        class Splitter < StringScanner
+          OPEN_PAREN = /\(/.freeze
+          CLOSE_PAREN = /\)/.freeze
+          UNQUOTED_RE = /[^,)]*/.freeze
+          SEP_RE = /[,)]/.freeze
+          QUOTE_RE = /"/.freeze
+          QUOTE_SEP_RE = /"[,)]/.freeze
+          QUOTED_RE = /(\\.|""|[^"])*/.freeze
+          REPLACE_RE = /\\(.)|"(")/.freeze
+          REPLACE_WITH = '\1\2'.freeze
+
+          # Split the stored string into an array of strings, handling
+          # the different types of quoting.
+          def parse
+            return @result if @result
+            values = []
+            skip(OPEN_PAREN)
+            if skip(CLOSE_PAREN)
+              values << nil
+            else
+              until eos?
+                if skip(QUOTE_RE)
+                  values << scan(QUOTED_RE).gsub(REPLACE_RE, REPLACE_WITH)
+                  skip(QUOTE_SEP_RE)
+                else
+                  v = scan(UNQUOTED_RE)
+                  values << (v unless v.empty?)
+                  skip(SEP_RE)
+                end
+              end
+            end
+            values
+          end
+        end
+
+        def self.parse_data(string)
+          Splitter.new(string).parse
+        end
+      end
+    end
+  end
 end

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

@@ -6,12 +6,12 @@ require 'rails'
 
 class PostgresCompositeTypesRailtie < Rails::Railtie
 
-	initializer 'activerecord-postgres-composite-types' do
-		ActiveSupport.on_load :active_record do
-			require "activerecord-postgres-composite-types/active_record"
-			require 'postgres_composite_type'
-		end
-	end
+  initializer 'activerecord-postgres-composite-types' do
+    ActiveSupport.on_load :active_record do
+      require "activerecord-postgres-composite-types/active_record"
+      require 'postgres_composite_type'
+    end
+  end
 
 end
 

data/lib/postgres_composite_type.rb

@@ -1,106 +1,106 @@
 require 'activerecord-postgres-composite-types/active_record'
 
 class PostgresCompositeType
-	include Comparable
+  include Comparable
 
-	class << self
-		# The PostgreSQL type name as symbol
-		attr_reader :type
-		# Column definition read from db schema
-		attr_reader :columns
+  class << self
+    # The PostgreSQL type name as symbol
+    attr_reader :type
+    # Column definition read from db schema
+    attr_reader :columns
 
-		# Link PostgreSQL type given by the name with this class.
-		# Usage:
-		#
-		# class ComplexType < PostgresCompositeType
-		#   register_type :complex
-		# end
-		#
-		# @param [Symbol] :type the PostgreSQL type name
-		def register_type(type)
-			@type = type.to_sym
-			ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.register_composite_type_class(self)
-		end
+    # Link PostgreSQL type given by the name with this class.
+    # Usage:
+    #
+    # class ComplexType < PostgresCompositeType
+    #   register_type :complex
+    # end
+    #
+    # @param [Symbol] :type the PostgreSQL type name
+    def register_type(type)
+      @type = type.to_sym
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.register_composite_type_class(self)
+    end
 
-		# Be default the ActiveRecord::Base connection is used when reading type definition.
-		# If you want to use connection linked with another class use this method.
-		# Usage
-		#
-		# class ComplexType < PostgresCompositeType
-		#   register_type :complex
-		#   use_connection_class MyRecordConnectedToDifferentDB
-		# end
-		#
-		# @param [Class] :active_record_class the ActiveRecord model class
-		def use_connection_class(active_record_class)
-			@connection_class = active_record_class
-		end
+    # Be default the ActiveRecord::Base connection is used when reading type definition.
+    # If you want to use connection linked with another class use this method.
+    # Usage
+    #
+    # class ComplexType < PostgresCompositeType
+    #   register_type :complex
+    #   use_connection_class MyRecordConnectedToDifferentDB
+    # end
+    #
+    # @param [Class] :active_record_class the ActiveRecord model class
+    def use_connection_class(active_record_class)
+      @connection_class = active_record_class
+    end
 
-		# :nodoc:
-		def connection
-			(@connection_class || ActiveRecord::Base).connection
-		end
+    # :nodoc:
+    def connection
+      (@connection_class || ActiveRecord::Base).connection
+    end
 
-		# :nodoc:
-		def connected?
-			(@connection_class || ActiveRecord::Base).connected?
-		end
+    # :nodoc:
+    def connected?
+      (@connection_class || ActiveRecord::Base).connected?
+    end
 
-		# :nodoc:
-		def initialize_column_definition
-			unless @columns
-				@columns = self.connection.columns(type)
-				attr_accessor *@columns.map(&:name)
-			end
-		end
-	end
+    # :nodoc:
+    def initialize_column_definition
+      unless @columns
+        @columns = self.connection.columns(type)
+        attr_accessor *@columns.map(&:name)
+      end
+    end
+  end
 
-	def initialize(value)
-		self.class.initialize_column_definition
+  def initialize(value)
+    self.class.initialize_column_definition
 
-		case value
-			when String
-				ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_composite_type(self.class, value)
-			when Array
-				set_values value
-			when Hash
-				set_attributes value
-			else
-				raise "Unexpected value: #{value.inspect}"
-		end
-	end
+    case value
+      when String
+        ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_composite_type(self.class, value)
+      when Array
+        set_values value
+      when Hash
+        set_attributes value
+      else
+        raise "Unexpected value: #{value.inspect}"
+    end
+  end
 
-	def <=>(another)
-		return nil if (self.class <=> another.class) == nil
-		self.class.columns.each do |column|
-			v1 = self.send(column.name)
-			v2 = another.send(column.name)
-			return v1 <=> v2 unless v1 == v2
-		end
-		0
-	end
+  def <=>(another)
+    return nil if (self.class <=> another.class) == nil
+    self.class.columns.each do |column|
+      v1 = self.send(column.name)
+      v2 = another.send(column.name)
+      return v1 <=> v2 unless v1 == v2
+    end
+    0
+  end
 
-	private
+  private
 
-	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
-			send "#{name}=", value
-		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
+      send "#{name}=", value
+    end
+  end
 
-	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
-			send "#{column.name}=", values[i]
-		end
-	end
+  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
+      send "#{column.name}=", values[i]
+    end
+  end
 
 end