activerecord-postgres-composite-types 0.2.4 → 0.2.5

data/test/composite_types.rb

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

data/test/helper.rb

@@ -30,14 +30,14 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'activerecord-postgres-composite-types'
 
 ActiveSupport.on_load :active_record do
-	require_relative 'composite_types'
+  require_relative 'composite_types'
 end
 
 Combustion.path = 'test/internal'
 Combustion.initialize! :active_record
 
 class Test::Unit::TestCase
-	def connection
-		ActiveRecord::Base.connection
-	end
+  def connection
+    ActiveRecord::Base.connection
+  end
 end

data/test/internal/db/schema.rb

@@ -1,24 +1,24 @@
 require "activerecord-postgres-composite-types/active_record"
 
 ActiveRecord::Schema.define do
-	execute "CREATE TYPE compfoo AS (f1 int, f2 text)"
-	execute "CREATE TYPE my_type AS (name varchar, number int, date timestamp)"
-	execute "CREATE DOMAIN rgb_color AS TEXT CHECK(VALUE IN ('red', 'green', 'blue'))"
-	execute "CREATE TYPE nested_type AS (comp compfoo, color rgb_color)"
-	execute "CREATE TYPE nested_nested_type AS (nested nested_type, color rgb_color)"
+  execute "CREATE TYPE compfoo AS (f1 int, f2 text)"
+  execute "CREATE TYPE my_type AS (name varchar, number int, date timestamp)"
+  execute "CREATE DOMAIN rgb_color AS TEXT CHECK(VALUE IN ('red', 'green', 'blue'))"
+  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 :foos, :id => false do |t|
-		t.column :comp, :compfoo, default: "(0,\"\")"
-	end
+  create_table :foos, :id => false do |t|
+    t.column :comp, :compfoo, default: "(0,\"\")"
+  end
 
-	create_table :bars, :id => false do |t|
-		t.column :nested, :nested_type
-	end
+  create_table :bars, :id => false do |t|
+    t.column :nested, :nested_type
+  end
 
-	create_table :bar2s, :id => false do |t|
-		t.column :nested, :nested_nested_type
-	end
+  create_table :bar2s, :id => false do |t|
+    t.column :nested, :nested_nested_type
+  end
 
-	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'))"
+  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

data/test/test_composite_type_class.rb

@@ -2,40 +2,56 @@ require_relative 'helper'
 
 class TestCompositeTypeClass < Test::Unit::TestCase
 
-	PostgreSQLColumn = ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-
-	should "define accessors" do
-		assert MyType.method_defined?(:name)
-		assert MyType.method_defined?(:name=)
-		assert MyType.method_defined?(:number)
-		assert MyType.method_defined?(:number=)
-		assert MyType.method_defined?(:date)
-		assert MyType.method_defined?(:date=)
-	end
-
-	should "be created by adapter from string" do
-		value = PostgreSQLColumn.string_to_composite_type(MyType, "(text,5,2014-08-27 00:00:00)")
-		assert_equal 'text', value.name
-		assert_equal 5, value.number
-		assert_equal Time.parse('2014-08-27 00:00:00 UTC'), value.date
-	end
-
-	should "accept escaped string" do
-		value = PostgreSQLColumn.string_to_composite_type(MyType, '("text\'s",125,"2014-08-27 10:00:00")')
-		assert_equal "text's", value.name
-		assert_equal 125, value.number
-		assert_equal Time.parse('2014-08-27 10:00:00 UTC'), value.date
-	end
-
-	should "initialize with hash" do
-		value = MyType.new(number: 1, name: 'abc', date: Time.parse('2014-08-27 12:00:00 UTC'))
-		assert_equal 'abc', value.name
-		assert_equal 1, value.number
-		assert_equal Time.parse('2014-08-27 12:00:00 UTC'), value.date
-	end
-
-	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)
-	end
+  PostgreSQLColumn = ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+
+  should "define accessors" do
+    assert MyType.method_defined?(:name)
+    assert MyType.method_defined?(:name=)
+    assert MyType.method_defined?(:number)
+    assert MyType.method_defined?(:number=)
+    assert MyType.method_defined?(:date)
+    assert MyType.method_defined?(:date=)
+  end
+
+  should "be created by adapter from string" do
+    value = PostgreSQLColumn.string_to_composite_type(MyType, "(text,5,2014-08-27 00:00:00)")
+    assert_equal 'text', value.name
+    assert_equal 5, value.number
+    assert_equal Time.parse('2014-08-27 00:00:00 UTC'), value.date
+  end
+
+  should "accept escaped string" do
+    value = PostgreSQLColumn.string_to_composite_type(MyType, '("text\'s",125,"2014-08-27 10:00:00")')
+    assert_equal "text's", value.name
+    assert_equal 125, value.number
+    assert_equal Time.parse('2014-08-27 10:00:00 UTC'), value.date
+  end
+
+  should "initialize with hash" do
+    value = MyType.new(number: 1, name: 'abc', date: Time.parse('2014-08-27 12:00:00 UTC'))
+    assert_equal 'abc', value.name
+    assert_equal 1, value.number
+    assert_equal Time.parse('2014-08-27 12:00:00 UTC'), value.date
+  end
+
+  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)
+  end
+
+  should "parse string and return array" do
+    result = PostgreSQLColumn::CompositeTypeParser.parse_data("(text,5,2014-08-27 00:00:00)")
+    assert_equal ["text", "5", "2014-08-27 00:00:00"], result
+  end
+
+  should "parse string and return array 2" do
+    result = PostgreSQLColumn::CompositeTypeParser.parse_data('(text,5,"(titi,tata)",2014-08-27 00:00:00)')
+    assert_equal ["text", "5", '(titi,tata)', "2014-08-27 00:00:00"], result
+  end
+
+  should "parse string and return array 3" do
+    result = PostgreSQLColumn::CompositeTypeParser.parse_data('(text,5,"(titi,tata,""(tutu""""tata,tete)"")",2014-08-27 00:00:00)')
+    assert_equal ["text", "5", '(titi,tata,"(tutu""tata,tete)")', "2014-08-27 00:00:00"], result
+  end
+
 end

data/test/test_nested_types.rb

@@ -1,22 +1,22 @@
 require_relative 'helper'
 
 class TestNestedTypes < Test::Unit::TestCase
-	class Bar < ActiveRecord::Base
-	end
-
-	class Bar2 < ActiveRecord::Base
-	end
-
-	should "cast value properly" do
-		bars = Bar.order('(nested).comp.f1').all
-		assert_equal 2, bars.size
-		assert_kind_of NestedType, bars[0].nested
-		assert_equal Compfoo.new([0,'abc']), bars[0].nested.comp
-		assert_equal 'red', bars[0].nested.color
-		assert_kind_of NestedType, bars[1].nested
-		assert_equal Compfoo.new([1,'cba']), bars[1].nested.comp
-		assert_equal 'blue', bars[1].nested.color
-	end
+  class Bar < ActiveRecord::Base
+  end
+
+  class Bar2 < ActiveRecord::Base
+  end
+
+  should "cast value properly" do
+    bars = Bar.order('(nested).comp.f1').all
+    assert_equal 2, bars.size
+    assert_kind_of NestedType, bars[0].nested
+    assert_equal Compfoo.new([0, 'abc']), bars[0].nested.comp
+    assert_equal 'red', bars[0].nested.color
+    assert_kind_of NestedType, bars[1].nested
+    assert_equal Compfoo.new([1, 'cba']), bars[1].nested.comp
+    assert_equal 'blue', bars[1].nested.color
+  end
 
   should "insert with nested type" do
     bar = Bar.new(nested: {comp: Compfoo.new([2, 'bac']), color: 'red'})
@@ -44,4 +44,22 @@ class TestNestedTypes < Test::Unit::TestCase
     assert !Bar2.where(nested: NestedNestedType.new(nested: {comp: [1, 'dca'], color: 'red'}, color: 'red')).exists?
     assert Bar2.where(nested: NestedNestedType.new(nested: {comp: [1, 'dca'], color: 'blue'}, color: 'red')).exists?
   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
+  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'})
+    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'})
+    assert_equal 'green', Bar2.all.to_a.last.nested.color
+    assert_equal 'dc\\a', Bar2.all.to_a.last.nested.nested.comp.f2
+  end
 end

data/test/test_postgres_composite_types.rb

@@ -1,48 +1,48 @@
 require_relative 'helper'
 
 class TestPostgresCompositeTypes < Test::Unit::TestCase
-	class Foo < ActiveRecord::Base
-
-	end
-
-	should "cast value properly" do
-		foos = Foo.all
-		assert_equal 2, foos.size
-		assert_equal 0, foos[0].comp.f1
-		assert_equal "abc", foos[0].comp.f2
-		assert_equal 1, foos[1].comp.f1
-		assert_equal "a/b'c\\d e f", foos[1].comp.f2
-	end
-
-	should "accept composite type in where clausure" do
-		sql = Foo.where(comp: Compfoo.new([123, 'text 1'])).to_sql
-		assert_equal %Q(SELECT "foos".* FROM "foos" WHERE "foos"."comp" = '(123,"text 1")'::compfoo), sql.gsub(/ +/, ' ')
-	end
-
-	should "create new record with compound object" do
-		foo = Foo.create!(comp: Compfoo.new([123, 'text 1']))
-
-		assert_kind_of Compfoo, foo.comp
-		assert_equal 123, foo.comp.f1
-		assert_equal 'text 1', foo.comp.f2
-		assert Foo.where(comp: Compfoo.new([123, 'text 1'])).exists?
-	end
-
-	should "create new record with hash" do
-		foo = Foo.create!(comp: {f1: 321, f2: 'text 2'})
-
-		assert_kind_of Compfoo, foo.comp
-		assert_equal 321, foo.comp.f1
-		assert_equal 'text 2', foo.comp.f2
-		assert Foo.where(comp: Compfoo.new({f1: 321, f2: 'text 2'})).exists?
-	end
-
-	should "create new record with array" do
-		foo = Foo.create!(comp: [111, 'text 3'])
-
-		assert_kind_of Compfoo, foo.comp
-		assert_equal 111, foo.comp.f1
-		assert_equal 'text 3', foo.comp.f2
-		assert Foo.where(comp: Compfoo.new({f1: 111, f2: 'text 3'})).exists?
-	end
+  class Foo < ActiveRecord::Base
+
+  end
+
+  should "cast value properly" do
+    foos = Foo.all
+    assert_equal 2, foos.size
+    assert_equal 0, foos[0].comp.f1
+    assert_equal "abc", foos[0].comp.f2
+    assert_equal 1, foos[1].comp.f1
+    assert_equal "a/b'c\\d e f", foos[1].comp.f2
+  end
+
+  should "accept composite type in where clausure" do
+    sql = Foo.where(comp: Compfoo.new([123, 'text 1'])).to_sql
+    assert_equal %Q(SELECT "foos".* FROM "foos" WHERE "foos"."comp" = '(123,"text 1")'::compfoo), sql.gsub(/ +/, ' ')
+  end
+
+  should "create new record with compound object" do
+    foo = Foo.create!(comp: Compfoo.new([123, 'text 1']))
+
+    assert_kind_of Compfoo, foo.comp
+    assert_equal 123, foo.comp.f1
+    assert_equal 'text 1', foo.comp.f2
+    assert Foo.where(comp: Compfoo.new([123, 'text 1'])).exists?
+  end
+
+  should "create new record with hash" do
+    foo = Foo.create!(comp: {f1: 321, f2: 'text 2'})
+
+    assert_kind_of Compfoo, foo.comp
+    assert_equal 321, foo.comp.f1
+    assert_equal 'text 2', foo.comp.f2
+    assert Foo.where(comp: Compfoo.new({f1: 321, f2: 'text 2'})).exists?
+  end
+
+  should "create new record with array" do
+    foo = Foo.create!(comp: [111, 'text 3'])
+
+    assert_kind_of Compfoo, foo.comp
+    assert_equal 111, foo.comp.f1
+    assert_equal 'text 3', foo.comp.f2
+    assert Foo.where(comp: Compfoo.new({f1: 111, f2: 'text 3'})).exists?
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgres-composite-types
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Rafal Bigaj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-28 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -202,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: ActiveRecord composite types support