activerecord-postgres-composite-types 0.2.1

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

@@ -0,0 +1,104 @@
+# ActiveRecord 3.X specific extensions.
+module ActiveRecord
+
+	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
+
+			alias_method_chain :type_cast, :composite_types
+		end
+
+		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
+
+			alias_method_chain :type_cast, :composite_types
+
+			# quote_and_escape - Rails 4 code
+
+			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.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(value)
+				end
+			end
+
+			alias_method_chain :type_cast_code, :composite_types
+		end
+	end
+
+	module AttributeMethods
+		module CompositeTypes
+			extend ActiveSupport::Concern
+
+			def type_cast_attribute_for_write(column, value)
+				if 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
+end

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

@@ -0,0 +1,103 @@
+# ActiveRecord 3.X specific extensions.
+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)
+					# 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
+
+				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
+
+			# 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
+
+		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
+
+			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
+						adapter.type_cast(value, column, true)
+					end
+				end
+				"(#{quoted_values.join(',')})"
+			end
+
+
+		end
+	end
+end

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

@@ -0,0 +1,95 @@
+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
+end

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

@@ -0,0 +1,75 @@
+class PostgresCompositeType
+	include Comparable
+
+	class << self
+		# TODO: doc
+		attr_reader :type
+		# TODO: doc
+		attr_reader :columns
+
+		def register_type(type)
+			@type = type.to_sym
+			ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.register_composite_type_class(self)
+		end
+
+		def use_connection_class(active_record_class)
+			@connection_class = active_record_class
+		end
+
+		def connection
+			(@connection_class || ActiveRecord::Base).connection
+		end
+
+		def connected?
+			(@connection_class || ActiveRecord::Base).connected?
+		end
+
+		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
+
+		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
+
+	private
+
+	def set_attributes(values)
+		values.each do |name, value|
+			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|
+			send "#{column.name}=", values[i]
+		end
+	end
+
+end

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

@@ -0,0 +1,16 @@
+require 'rails'
+
+# = Postgres Composite Types Railtie
+#
+# Creates a new railtie to initialize ActiveRecord properly
+
+class PostgresCompositeTypesRailtie < Rails::Railtie
+
+  initializer 'activerecord-postgres-composite-types' do
+    ActiveSupport.on_load :active_record do
+      require "activerecord-postgres-composite-types/active_record"
+    end
+  end
+
+end
+

data/test/composite_types.rb

@@ -0,0 +1,16 @@
+
+if ActiveRecord::VERSION::MAJOR > 3
+	ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID.alias_type 'rgb_color', 'text'
+end
+
+class Compfoo < PostgresCompositeType
+	register_type :compfoo
+end
+
+class MyType < PostgresCompositeType
+	register_type :my_type
+end
+
+class NestedType < PostgresCompositeType
+	register_type :nested_type
+end

data/test/helper.rb

@@ -0,0 +1,44 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_profile 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.require(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'activerecord-postgres-composite-types'
+
+ActiveSupport.on_load :active_record do
+	require 'activerecord-postgres-composite-types/active_record'
+	require_relative 'composite_types.rb'
+end
+
+Combustion.path = 'test/internal'
+Combustion.initialize! :active_record
+
+class Test::Unit::TestCase
+	def connection
+		ActiveRecord::Base.connection
+	end
+end