torque-postgresql 2.1.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f5815c2fe0a3682db3ccb907a29aa171382bfa6d70ffcb58ef7e7bdbb840f65
-  data.tar.gz: 32ae2c431e089c2c83d6c73be202ae86e79c129f1a79a08ca596ff87ffb231f6
+  metadata.gz: fcb69118c9cca1afe5ef21a9ed9b4cf98e9036108b739707a1e7f65058aaaf84
+  data.tar.gz: d7ca85705f802c0d15c0aabca99a9ec17b8403e60e912724b609d8b93cd7bd86
 SHA512:
-  metadata.gz: 78c8d75e7b3534570caa48fe0a607417431813b04d842fb60b292d252d7ab0cb73ac16df488ba71242238f160ad746fe21ea162a988da0e11809c962e988b2d7
-  data.tar.gz: a9450b4271ddf00be01ef4fb1a45365970310887d0179c457928f8ab36d0be9378e9738befe3797380ace0cbb66181f973f4d966cd39cd3fff7eceef7afb8082
+  metadata.gz: 0a48ed549030276f9a3e4c845454eb89cf97b8d0bf3d00cd5431abd85a7317f6031e4f997e86ae3657012ca9d4578598d612a14c531247575f1d0496bc629f6e
+  data.tar.gz: 50a1817ef37c0c8d98a71b92500a73b420f5dc27cf9d19afc6aeb8492e3d4582b69ee9ada91b281699987cc4bb33a9d1df584219073d432299ebad53a4a29513

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -42,6 +42,8 @@ module Torque
           m.register_type 'interval', OID::Interval.new
           m.register_type 'line',     OID::Line.new
           m.register_type 'segment',  OID::Segment.new
+
+          m.alias_type 'regclass', 'varchar'
         end
 
         # :nodoc:
@@ -123,7 +125,7 @@ module Torque
           SQL
 
           tables.map do |(table, refs)|
-            [table, Coder.decode(refs)]
+            [table, PG::TextDecoder::Array.new.decode(refs)]
           end.to_h
         end
 
@@ -147,20 +149,6 @@ module Torque
           SQL
         end
 
-        # Extracts the value from a PostgreSQL column default definition.
-        def extract_value_from_default(default)
-          case default
-            # Array elements
-          when /\AARRAY\[(.*)\]\z/
-            # TODO: Improve this since it's not the most safe approach
-            eval(default.gsub(/ARRAY|::\w+(\[\])?/, ''))
-          else
-            super
-          end
-        rescue SyntaxError
-          # If somethin goes wrong with the eval, just return nil
-        end
-
       end
     end
   end

data/lib/torque/postgresql/adapter/oid/enum.rb

@@ -8,9 +8,6 @@ module Torque
 
           attr_reader :name, :klass, :set_klass, :enum_klass
 
-          # Delegate all Hash-like methods to the enum class
-          delegate *(Array.public_instance_methods - Object.public_methods), to: :@klass
-
           def self.create(row, type_map)
             name    = row['typname']
             oid     = row['oid'].to_i

data/lib/torque/postgresql/adapter/quoting.rb

@@ -20,7 +20,7 @@ module Torque
         end
 
         def quote_default_expression(value, column)
-          if value.class <= Array
+          if column.options.try(:[], :array) && value.class <= Array
             quote(value) + '::' + column.sql_type
           else
             super

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -70,7 +70,11 @@ module Torque
 
         # Returns all values that an enum type can have.
         def enum_values(name)
-          select_values("SELECT unnest(enum_range(NULL::#{name}))", 'SCHEMA')
+          select_values(<<-SQL.squish, 'SCHEMA')
+            SELECT enumlabel FROM pg_enum
+            WHERE enumtypid = #{quote(name)}::regtype::oid
+            ORDER BY enumsortorder
+          SQL
         end
 
         # Rewrite the method that creates tables to easily accept extra options

data/lib/torque/postgresql/adapter.rb

@@ -15,7 +15,14 @@ module Torque
       include DatabaseStatements
       include SchemaStatements
 
-      INJECT_WHERE_REGEX = /(DO UPDATE SET.*excluded\.[^ ]+) RETURNING/.freeze
+      # :nodoc:
+      class DeduplicatableArray < ::Array
+        def deduplicate
+          map { |value| -value }
+        end
+
+        alias :-@ :deduplicate
+      end
 
       # Get the current PostgreSQL version as a Gem Version.
       def version
@@ -29,19 +36,28 @@ module Torque
         super.merge(options.extract!(:inherits))
       end
 
-      # Allow filtered bulk insert by adding the where clause. This method is only used by
-      # +InsertAll+, so it somewhat safe to override it
+      # Allow filtered bulk insert by adding the where clause. This method is
+      # only used by +InsertAll+, so it somewhat safe to override it
       def build_insert_sql(insert)
         super.tap do |sql|
           if insert.update_duplicates? && insert.where_condition?
             if insert.returning
-              sql.gsub!(INJECT_WHERE_REGEX, "\\1 WHERE #{insert.where} RETURNING")
+              sql.sub!(' RETURNING ', " WHERE #{insert.where} RETURNING ")
             else
               sql << " WHERE #{insert.where}"
             end
           end
         end
       end
+
+      # Extend the extract default value to support array
+      def extract_value_from_default(default)
+        return super unless Torque::PostgreSQL.config.use_extended_defaults
+        return super unless default&.match(/ARRAY\[(.*?)\](?:::"?([\w. ]+)"?(?:\[\])+)?$/)
+
+        arr = $1.split(/(?!\B\[[^\]]*), ?(?![^\[]*\]\B)/)
+        DeduplicatableArray.new(arr.map(&method(:extract_value_from_default)))
+      end
     end
 
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend Adapter

data/lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -113,7 +113,7 @@ module Torque
         end
 
         def insert_record(record, *)
-          super.tap do |saved|
+          (record.persisted? || super).tap do |saved|
             ids_rewriter(record.read_attribute(klass_attr), :<<) if saved
           end
         end

data/lib/torque/postgresql/associations/preloader/association.rb

@@ -41,8 +41,8 @@ module Torque
               end
             end
 
-            if PostgreSQL::AR610
-            # This is how Rails 6.1 now load the records
+            if PostgreSQL::AR604
+            # This is how Rails 6.0.4 and 6.1 now load the records
               def load_records
                 return super unless connected_through_array?
 

data/lib/torque/postgresql/attributes/builder/period.rb

@@ -452,12 +452,8 @@ module Torque
             def instance_current_on?
               attr_value = threshold.present? ? method_names[:real] : attribute
               default_value = default.inspect
-              [
-                "return #{default_value} if #{attr_value}.nil?",
-                "return #{default_value} if #{attr_value}.min.try(:infinite?)",
-                "return #{default_value} if #{attr_value}.max.try(:infinite?)",
-                "#{attr_value}.min < value && #{attr_value}.max > value",
-              ].join("\n")
+
+              "#{attr_value}.nil? ? #{default_value} : #{attr_value}.include?(value)"
             end
 
             def instance_start

data/lib/torque/postgresql/attributes/enum.rb

@@ -29,7 +29,7 @@ module Torque
           def include_on(klass, method_name = nil)
             method_name ||= Torque::PostgreSQL.config.enum.base_method
             Builder.include_on(klass, method_name, Builder::Enum) do |builder|
-              defined_enums[builder.attribute.to_s] = builder.subtype
+              defined_enums[builder.attribute.to_s] = builder.subtype.klass
             end
           end
 

data/lib/torque/postgresql/base.rb

@@ -40,7 +40,7 @@ module Torque
 
             pg_class = ::Arel::Table.new('pg_class')
             source = ::Arel::Table.new(subclass.table_name, as: 'source')
-            quoted_id = ::Arel::Nodes::Quoted.new(self.class.connection.quote(id))
+            quoted_id = ::Arel::Nodes::Quoted.new(id)
 
             query = ::Arel::SelectManager.new(pg_class)
             query.join(source).on(pg_class['oid'].eq(source['tableoid']))

data/lib/torque/postgresql/config.rb

@@ -5,6 +5,7 @@ module Torque
     include ActiveSupport::Configurable
 
     # Stores a version check for compatibility purposes
+    AR604 = (ActiveRecord.gem_version >= Gem::Version.new('6.0.4'))
     AR610 = (ActiveRecord.gem_version >= Gem::Version.new('6.1.0'))
 
     # Use the same logger as the Active Record one
@@ -25,6 +26,11 @@ module Torque
     # same configuration is set to true
     config.eager_load = false
 
+    # This allows default values to have extended values like arrays and casted
+    # values. Extended defaults are still experimental, so enable and test it
+    # before using it in prod
+    config.use_extended_defaults = false
+
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)

data/lib/torque/postgresql/inheritance.rb

@@ -146,7 +146,7 @@ module Torque
             auto_cast = _auto_cast_attribute.to_s
             record_class = _record_class_attribute.to_s
             return super unless attributes.key?(record_class) &&
-               attributes.delete(auto_cast) && attributes[record_class] != table_name
+              attributes.delete(auto_cast) && attributes[record_class] != table_name
 
             klass = casted_dependents[attributes[record_class]]
             raise_unable_to_cast(attributes[record_class]) if klass.nil?

data/lib/torque/postgresql/reflection/belongs_to_many_reflection.rb

@@ -56,8 +56,10 @@ module Torque
       end
 
       ::ActiveRecord::Reflection.const_set(:BelongsToManyReflection, BelongsToManyReflection)
-      ::ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS
-        .push(:belongs_to_many)
+
+      reflection_class = ::ActiveRecord::Reflection::AssociationReflection
+      reflection_class::VALID_AUTOMATIC_INVERSE_MACROS.push(:belongs_to_many) \
+        if reflection_class.const_defined?('VALID_AUTOMATIC_INVERSE_MACROS')
     end
   end
 end

data/lib/torque/postgresql/relation/inheritance.rb

@@ -5,6 +5,8 @@ module Torque
     module Relation
       module Inheritance
 
+        # REGCLASS = ::Arel.sql('tableoid').cast('regclass')
+
         # :nodoc:
         def cast_records_value; get_value(:cast_records); end
         # :nodoc:
@@ -44,14 +46,8 @@ module Torque
 
         # Like #cast_records, but modifies relation in place
         def cast_records!(*types, **options)
-          record_class = self.class._record_class_attribute
-
-          with!(record_class)
-          if options[:filter]
-            table = record_class.to_s.camelize.underscore
-            where!(table => { record_class => types.map(&:table_name) })
-          end
-
+          where!(regclass.cast(:varchar).in(types.map(&:table_name))) if options[:filter]
+          self.select_extra_values += [regclass.as(_record_class_attribute.to_s)]
           self.cast_records_value = (types.present? ? types : model.casted_dependents.values)
           self
         end
@@ -109,13 +105,12 @@ module Torque
           end
 
           def build_auto_caster_marker(arel, types)
-            types = types.map(&:table_name)
-            type_attribute = self.class._record_class_attribute.to_s
-            auto_cast_attribute = self.class._auto_cast_attribute.to_s
+            attribute = regclass.cast(:varchar).in(types.map(&:table_name))
+            attribute.as(self.class._auto_cast_attribute.to_s)
+          end
 
-            table = ::Arel::Table.new(type_attribute.camelize.underscore)
-            column = table[type_attribute].in(types)
-            ::Arel.sql(column.to_sql).as(auto_cast_attribute)
+          def regclass
+            arel_table['tableoid'].cast(:regclass)
           end
 
       end

data/lib/torque/postgresql/relation.rb

@@ -117,7 +117,7 @@ module Torque
       # because the type mapper may add new methods to the model. This happens
       # for the given model Klass and its inheritances
       module Initializer
-        def initialize(klass, *)
+        def initialize(klass, *, **)
           super
 
           klass.superclass.send(:relation) if klass.define_attribute_methods &&

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '2.1.1'
+    VERSION = '2.2.1'
   end
 end

data/lib/torque/postgresql.rb

@@ -23,7 +23,6 @@ require 'torque/postgresql/auxiliary_statement'
 require 'torque/postgresql/base'
 require 'torque/postgresql/inheritance'
 require 'torque/postgresql/insert_all'
-require 'torque/postgresql/coder'
 require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
 require 'torque/postgresql/reflection'

data/lib/torque/range.rb

@@ -17,6 +17,4 @@ module Torque
     end
     alias_method :|, :union
   end
-
-  ::Range.include(Range)
 end

data/spec/factories/item.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :item do
+    name { Faker::Lorem.sentence }
+  end
+end

data/spec/models/item.rb

@@ -0,0 +1,3 @@
+class Item < ActiveRecord::Base
+  belongs_to_many :tags
+end

data/spec/models/question.rb

@@ -0,0 +1,3 @@
+class Question < ActiveRecord::Base
+  self.implicit_order_column = 'created_at'
+end

data/spec/models/question_select.rb

@@ -0,0 +1,2 @@
+class QuestionSelect < Question
+end

data/spec/schema.rb

@@ -11,13 +11,14 @@
 # It's strongly recommended that you check this file into your version control system.
 
 begin
-  version = 63
+  version = 73
 
   raise SystemExit if ActiveRecord::Migrator.current_version == version
   ActiveRecord::Schema.define(version: version) do
     self.verbose = false
 
     # These are extensions that must be enabled in order to support this database
+    enable_extension "pgcrypto"
     enable_extension "plpgsql"
 
     # These are user-defined types used on this database
@@ -102,6 +103,13 @@ begin
       t.index ["author_id"], name: "index_posts_on_author_id", using: :btree
     end
 
+    create_table "items", force: :cascade do |t|
+      t.string   "name"
+      t.bigint   "tag_ids", array: true, default: "{1}"
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
     create_table "users", force: :cascade do |t|
       t.string   "name",       null: false
       t.enum     "role",                    subtype: :roles, default: :visitor
@@ -118,6 +126,12 @@ begin
       t.datetime "updated_at", null: false
     end
 
+    create_table "questions", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
+      t.string   "title"
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
     create_table "activity_books", force: :cascade, inherits: :activities do |t|
       t.text     "description"
       t.string   "url"
@@ -132,6 +146,10 @@ begin
 
     create_table "activity_post_samples", force: :cascade, inherits: :activity_posts
 
+    create_table "question_selects", force: :cascade, inherits: :questions do |t|
+      t.string  "options", array: true
+    end
+
     # create_table "activity_blanks", force: :cascade, inherits: :activities
 
     # create_table "activity_images", force: :cascade, inherits: [:activities, :images]

data/spec/tests/arel_spec.rb

@@ -48,6 +48,36 @@ RSpec.describe 'Arel' do
     end
   end
 
+  context 'on default value' do
+    let(:connection) { ActiveRecord::Base.connection }
+
+    before(:context) { Torque::PostgreSQL.config.use_extended_defaults = true }
+    after(:context) { Torque::PostgreSQL.config.use_extended_defaults = false }
+    after { Author.reset_column_information }
+
+    it 'does not break jsonb' do
+      expect { connection.add_column(:authors, :profile, :jsonb, default: []) }.not_to raise_error
+      expect(Author.columns_hash['profile'].default).to eq('[]')
+    end
+
+    it 'works properly when column is an array' do
+      expect { connection.add_column(:authors, :tag_ids, :bigint, array: true, default: []) }.not_to raise_error
+      expect(Author.columns_hash['tag_ids'].default).to eq([])
+    end
+
+    it 'works with an array with enum values' do
+      value = ['visitor', 'assistant']
+      expect { connection.add_column(:authors, :roles, :roles, array: true, default: value) }.not_to raise_error
+      expect(Author.columns_hash['roles'].default).to eq(value)
+    end
+
+    it 'works with multi dimentional array' do
+      value = [['1', '2'], ['3', '4']]
+      expect { connection.add_column(:authors, :tag_ids, :string, array: true, default: value) }.not_to raise_error
+      expect(Author.columns_hash['tag_ids'].default).to eq(value)
+    end
+  end
+
   context 'on cast' do
     it 'provides an array method' do
       sample1 = ::Arel.array(1, 2, 3, 4)

data/spec/tests/belongs_to_many_spec.rb

@@ -147,6 +147,22 @@ RSpec.describe 'BelongsToMany' do
       expect(record.tags.count).to be_eql(5)
     end
 
+    it 'does not trigger after commit on the associated record' do
+      called = false
+
+      tag = FactoryBot.create(:tag)
+      Tag.after_commit { called = true }
+
+      expect(called).to be_falsey
+
+      subject.tags << tag
+
+      expect(subject.tag_ids).to be_eql([tag.id])
+      expect(called).to be_falsey
+
+      Tag.reset_callbacks(:commit)
+    end
+
     it 'can build an associated record' do
       record = subject.tags.build(name: 'Test')
       expect(record).to be_a(other)
@@ -330,17 +346,11 @@ RSpec.describe 'BelongsToMany' do
     end
 
     context 'When the attribute has a default value' do
-      after(:all) { Video.reset_column_information }
-      let(:sql) { %{ALTER TABLE "videos" ALTER COLUMN "tag_ids" SET DEFAULT '{}'::bigint[]} }
-
-      before do
-        Video.connection.execute(sql)
-        Video.reset_column_information
-      end
+      subject { FactoryBot.create(:item) }
 
       it 'will always return the column default value' do
         expect(subject.tag_ids).to be_a(Array)
-        expect(subject.tag_ids).to be_empty
+        expect(subject.tag_ids).to be_eql([1])
       end
 
       it 'will keep the value as an array even when the association is cleared' do
@@ -349,12 +359,12 @@ RSpec.describe 'BelongsToMany' do
 
         subject.reload
         expect(subject.tag_ids).to be_a(Array)
-        expect(subject.tag_ids).not_to be_empty
+        expect(subject.tag_ids).not_to be_eql([1, *records.map(&:id)])
 
         subject.tags.clear
         subject.reload
         expect(subject.tag_ids).to be_a(Array)
-        expect(subject.tag_ids).to be_empty
+        expect(subject.tag_ids).to be_eql([1])
       end
     end
 

data/spec/tests/period_spec.rb

@@ -266,6 +266,15 @@ RSpec.describe 'Period' do
 
         instance.period = 4.hour.from_now.utc..6.hour.from_now.utc
         expect(instance).not_to be_current_period
+
+        instance.period = [nil, 4.hours.ago.utc]
+        expect(instance).not_to be_current_period
+
+        instance.period = [4.hours.from_now.utc, nil]
+        expect(instance).not_to be_current_period
+
+        instance.period = [nil, nil]
+        expect(instance).to be_current_period
       end
 
       it 'checks fro current based on a value' do

data/spec/tests/range_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe 'Range' do
+RSpec.xdescribe 'Range' do
   let(:sample) { (5..15) }
 
   it 'has intersection' do

data/spec/tests/table_inheritance_spec.rb

@@ -292,14 +292,12 @@ RSpec.describe 'TableInheritance' do
       end
 
       it 'adds all statements to load all the necessary records' do
-        result = 'WITH "record_class" AS (SELECT "pg_class"."oid", "pg_class"."relname" AS _record_class FROM "pg_class")'
-        result << ' SELECT "activities".*, "record_class"."_record_class", "i_0"."description"'
+        result = 'SELECT "activities".*, "activities"."tableoid"::regclass AS _record_class, "i_0"."description"'
         result << ', COALESCE("i_0"."url", "i_1"."url", "i_2"."url") AS url, "i_0"."activated" AS activity_books__activated'
         result << ', "i_1"."activated" AS activity_posts__activated, "i_2"."activated" AS activity_post_samples__activated'
         result << ', COALESCE("i_1"."file", "i_2"."file") AS file, COALESCE("i_1"."post_id", "i_2"."post_id") AS post_id'
-        result << ", \"record_class\".\"_record_class\" IN ('activity_books', 'activity_posts', 'activity_post_samples') AS _auto_cast"
+        result << ", \"activities\".\"tableoid\"::regclass::varchar IN ('activity_books', 'activity_posts', 'activity_post_samples') AS _auto_cast"
         result << ' FROM "activities"'
-        result << ' INNER JOIN "record_class" ON "record_class"."oid" = "activities"."tableoid"'
         result << ' LEFT OUTER JOIN "activity_books" "i_0" ON "activities"."id" = "i_0"."id"'
         result << ' LEFT OUTER JOIN "activity_posts" "i_1" ON "activities"."id" = "i_1"."id"'
         result << ' LEFT OUTER JOIN "activity_post_samples" "i_2" ON "activities"."id" = "i_2"."id"'
@@ -307,33 +305,27 @@ RSpec.describe 'TableInheritance' do
       end
 
       it 'can be have simplefied joins' do
-        result = 'WITH "record_class" AS (SELECT "pg_class"."oid", "pg_class"."relname" AS _record_class FROM "pg_class")'
-        result << ' SELECT "activities".*, "record_class"."_record_class"'
+        result = 'SELECT "activities".*, "activities"."tableoid"::regclass AS _record_class'
         result << ', "i_0"."description", "i_0"."url", "i_0"."activated"'
-        result << ", \"record_class\".\"_record_class\" IN ('activity_books') AS _auto_cast"
+        result << ", \"activities\".\"tableoid\"::regclass::varchar IN ('activity_books') AS _auto_cast"
         result << ' FROM "activities"'
-        result << ' INNER JOIN "record_class" ON "record_class"."oid" = "activities"."tableoid"'
         result << ' LEFT OUTER JOIN "activity_books" "i_0" ON "activities"."id" = "i_0"."id"'
         expect(base.cast_records(child).all.to_sql).to eql(result)
       end
 
       it 'can be filtered by record type' do
-        result = 'WITH "record_class" AS (SELECT "pg_class"."oid", "pg_class"."relname" AS _record_class FROM "pg_class")'
-        result << ' SELECT "activities".*, "record_class"."_record_class"'
+        result = 'SELECT "activities".*, "activities"."tableoid"::regclass AS _record_class'
         result << ', "i_0"."description", "i_0"."url", "i_0"."activated"'
-        result << ", \"record_class\".\"_record_class\" IN ('activity_books') AS _auto_cast"
+        result << ", \"activities\".\"tableoid\"::regclass::varchar IN ('activity_books') AS _auto_cast"
         result << ' FROM "activities"'
-        result << ' INNER JOIN "record_class" ON "record_class"."oid" = "activities"."tableoid"'
         result << ' LEFT OUTER JOIN "activity_books" "i_0" ON "activities"."id" = "i_0"."id"'
-        result << " WHERE \"record_class\".\"_record_class\" = 'activity_books'"
+        result << " WHERE \"activities\".\"tableoid\"::regclass::varchar IN ('activity_books')"
         expect(base.cast_records(child, filter: true).all.to_sql).to eql(result)
       end
 
       it 'works with count and does not add extra columns' do
-        result = 'WITH "record_class" AS (SELECT "pg_class"."oid", "pg_class"."relname" AS _record_class FROM "pg_class")'
-        result << ' SELECT COUNT(*)'
+        result = 'SELECT COUNT(*)'
         result << ' FROM "activities"'
-        result << ' INNER JOIN "record_class" ON "record_class"."oid" = "activities"."tableoid"'
         result << ' LEFT OUTER JOIN "activity_books" "i_0" ON "activities"."id" = "i_0"."id"'
         result << ' LEFT OUTER JOIN "activity_posts" "i_1" ON "activities"."id" = "i_1"."id"'
         result << ' LEFT OUTER JOIN "activity_post_samples" "i_2" ON "activities"."id" = "i_2"."id"'
@@ -342,10 +334,8 @@ RSpec.describe 'TableInheritance' do
       end
 
       it 'works with sum and does not add extra columns' do
-        result = 'WITH "record_class" AS (SELECT "pg_class"."oid", "pg_class"."relname" AS _record_class FROM "pg_class")'
-        result << ' SELECT SUM("activities"."id")'
+        result = 'SELECT SUM("activities"."id")'
         result << ' FROM "activities"'
-        result << ' INNER JOIN "record_class" ON "record_class"."oid" = "activities"."tableoid"'
         result << ' LEFT OUTER JOIN "activity_books" "i_0" ON "activities"."id" = "i_0"."id"'
         result << ' LEFT OUTER JOIN "activity_posts" "i_1" ON "activities"."id" = "i_1"."id"'
         result << ' LEFT OUTER JOIN "activity_post_samples" "i_2" ON "activities"."id" = "i_2"."id"'
@@ -387,10 +377,10 @@ RSpec.describe 'TableInheritance' do
         base.create(title: 'Activity test')
         child.create(title: 'Activity book')
         other.create(name: 'An author name')
+        base.instance_variable_set(:@casted_dependents, nil)
       end
 
       it 'does not affect normal records' do
-        base.instance_variable_set(:@casted_dependents, {})
         expect(base.first.cast_record).to be_a(base)
         expect(child.first.cast_record).to be_a(child)
         expect(other.first.cast_record).to be_a(other)
@@ -408,9 +398,28 @@ RSpec.describe 'TableInheritance' do
       end
 
       it 'does trigger record casting when accessed through inheritance' do
-        base.instance_variable_set(:@casted_dependents, nil)
         expect(base.second.cast_record).to eql(child.first)
       end
+
+      context 'using uuid' do
+        let(:base) { Question }
+        let(:child) { QuestionSelect }
+
+        before :each do
+          base.create(title: 'Simple question')
+          child.create(title: 'Select question')
+          base.instance_variable_set(:@casted_dependents, nil)
+        end
+
+        it 'does not affect normal records' do
+          expect(base.first.cast_record).to be_a(base)
+          expect(child.first.cast_record).to be_a(child)
+        end
+
+        it 'does trigger record casting when accessed through inheritance' do
+          expect(base.second.cast_record).to eql(child.first)
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.1
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-04 00:00:00.000000000 Z
+date: 2021-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -215,7 +215,6 @@ files:
 - lib/torque/postgresql/auxiliary_statement.rb
 - lib/torque/postgresql/auxiliary_statement/settings.rb
 - lib/torque/postgresql/base.rb
-- lib/torque/postgresql/coder.rb
 - lib/torque/postgresql/collector.rb
 - lib/torque/postgresql/config.rb
 - lib/torque/postgresql/geometry_builder.rb
@@ -243,6 +242,7 @@ files:
 - spec/en.yml
 - spec/factories/authors.rb
 - spec/factories/comments.rb
+- spec/factories/item.rb
 - spec/factories/posts.rb
 - spec/factories/tags.rb
 - spec/factories/texts.rb
@@ -260,7 +260,10 @@ files:
 - spec/models/course.rb
 - spec/models/geometry.rb
 - spec/models/guest_comment.rb
+- spec/models/item.rb
 - spec/models/post.rb
+- spec/models/question.rb
+- spec/models/question_select.rb
 - spec/models/tag.rb
 - spec/models/text.rb
 - spec/models/time_keeper.rb
@@ -271,7 +274,6 @@ files:
 - spec/tests/arel_spec.rb
 - spec/tests/auxiliary_statement_spec.rb
 - spec/tests/belongs_to_many_spec.rb
-- spec/tests/coder_spec.rb
 - spec/tests/collector_spec.rb
 - spec/tests/distinct_on_spec.rb
 - spec/tests/enum_set_spec.rb
@@ -305,7 +307,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.14
 signing_key: 
 specification_version: 4
 summary: ActiveRecord extension to access PostgreSQL advanced resources
@@ -326,6 +328,9 @@ test_files:
 - spec/models/tag.rb
 - spec/models/time_keeper.rb
 - spec/models/video.rb
+- spec/models/item.rb
+- spec/models/question.rb
+- spec/models/question_select.rb
 - spec/factories/authors.rb
 - spec/factories/comments.rb
 - spec/factories/posts.rb
@@ -333,13 +338,11 @@ test_files:
 - spec/factories/texts.rb
 - spec/factories/users.rb
 - spec/factories/videos.rb
+- spec/factories/item.rb
 - spec/tests/geometric_builder_spec.rb
-- spec/tests/range_spec.rb
-- spec/tests/arel_spec.rb
-- spec/tests/insert_all_spec.rb
 - spec/tests/enum_spec.rb
-- spec/tests/period_spec.rb
-- spec/tests/coder_spec.rb
+- spec/tests/range_spec.rb
+- spec/tests/table_inheritance_spec.rb
 - spec/tests/collector_spec.rb
 - spec/tests/distinct_on_spec.rb
 - spec/tests/interval_spec.rb
@@ -347,10 +350,12 @@ test_files:
 - spec/tests/quoting_spec.rb
 - spec/tests/relation_spec.rb
 - spec/tests/auxiliary_statement_spec.rb
+- spec/tests/belongs_to_many_spec.rb
 - spec/tests/enum_set_spec.rb
 - spec/tests/has_many_spec.rb
-- spec/tests/belongs_to_many_spec.rb
-- spec/tests/table_inheritance_spec.rb
+- spec/tests/insert_all_spec.rb
+- spec/tests/arel_spec.rb
+- spec/tests/period_spec.rb
 - spec/mocks/cache_query.rb
 - spec/mocks/create_table.rb
 - spec/en.yml

data/lib/torque/postgresql/coder.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Torque
-  module PostgreSQL
-    module Coder
-
-      # This class represents an Record to be encoded, instead of a literal Array
-      Record = Class.new(Array)
-
-      class << self
-
-        NEED_QUOTE_FOR = /[\\"(){}, \t\n\r\v\f]/m
-        DELIMITER = ','
-
-        # This method replace the +read_array+ method from PG gem
-        # See https://github.com/ged/ruby-pg/blob/master/ext/pg_text_decoder.c#L177
-        # for more information
-        def decode(value)
-          # TODO: Use StringScanner
-          # See http://ruby-doc.org/stdlib-1.9.3/libdoc/strscan/rdoc/StringScanner.html
-          _decode(::StringIO.new(value))
-        end
-
-        # This method replace the ++ method from PG gem
-        # See https://github.com/ged/ruby-pg/blob/master/ext/pg_text_encoder.c#L398
-        # for more information
-        def encode(value)
-          _encode(value)
-        end
-
-        private
-
-          def _decode(stream)
-            quoted = 0
-            escaped = false
-            result = []
-            part = String.new
-
-            # Always start getting the non-collection character, the second char
-            stream.getc if stream.pos == 0
-
-            # Check for an empty list
-            return result if %w[} )].include?(stream.getc)
-
-            # If it's not an empty list, return one position before iterating
-            stream.pos -= 1
-            stream.each_char do |c|
-
-              case
-              when quoted < 1
-                case
-                when c == DELIMITER, c == '}', c == ')'
-
-                  unless escaped
-                    # Non-quoted empty string or NULL as extense
-                    part = nil if quoted == 0 && ( part.length == 0 || part == 'NULL' )
-                    result << part
-                  end
-
-                  return result unless c == DELIMITER
-
-                  escaped = false
-                  quoted = 0
-                  part = String.new
-
-                when c == '"'
-                  quoted = 1
-                when c == '{', c == '('
-                  result << _decode(stream)
-                  escaped = true
-                else
-                  part << c
-                end
-              when escaped
-                escaped = false
-                part << c
-              when c == '\\'
-                escaped = true
-              when c == '"'
-                if stream.getc == '"'
-                  part << c
-                else
-                  stream.pos -= 1
-                  quoted = -1
-                end
-              else
-                if ( c == '"' || c == "'" ) && stream.getc != c
-                  stream.pos -= 1
-                  quoted = -1
-                else
-                  part << c
-                end
-              end
-
-            end
-          end
-
-          def _encode(list)
-            is_record = list.is_a?(Record)
-            list.map! do |part|
-              case part
-              when NilClass
-                is_record ? '' : 'NULL'
-              when Array
-                _encode(part)
-              else
-                _quote(part.to_s)
-              end
-            end
-
-            result = is_record ? '(%s)' : '{%s}'
-            result % list.join(DELIMITER)
-          end
-
-          def _quote(string)
-            len = string.length
-
-            # Fast results
-            return '""' if len == 0
-            return '"NULL"' if len == 4 && string == 'NULL'
-
-            # Check if the string don't need quotes
-            return string unless string =~ NEED_QUOTE_FOR
-
-            # Use the original string escape function
-            PG::Connection.escape_string(string).inspect
-          end
-
-      end
-
-    end
-  end
-end

data/spec/tests/coder_spec.rb

@@ -1,367 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Complex coder', type: :helper do
-  let(:coder) { Torque::PostgreSQL::Coder }
-
-  context 'on decode' do
-
-    context 'one dimensional arrays' do
-      it 'returns an empty array' do
-        expect(coder.decode(%[{}])).to eql []
-      end
-
-      it 'returns an array of strings' do
-        expect(coder.decode(%[{1,2,3}])).to eql ['1','2','3']
-      end
-
-      it 'returns an array of strings, with nils replacing NULL characters' do
-        expect(coder.decode(%[{1,,NULL}])).to eql ['1',nil,nil]
-      end
-
-      it 'returns an array with the word NULL' do
-        expect(coder.decode(%[{1,"NULL",3}])).to eql ['1','NULL','3']
-      end
-
-      it 'returns an array of strings when containing commas in a quoted string' do
-        expect(coder.decode(%[{1,"2,3",4}])).to eql ['1','2,3','4']
-      end
-
-      it 'returns an array of strings when containing an escaped quote' do
-        expect(coder.decode(%[{1,"2\\",3",4}])).to eql ['1','2",3','4']
-      end
-
-      it 'returns an array of strings when containing an escaped backslash' do
-        expect(coder.decode(%[{1,"2\\\\",3,4}])).to eql ['1','2\\','3','4']
-        expect(coder.decode(%[{1,"2\\\\\\",3",4}])).to eql ['1','2\\",3','4']
-      end
-
-      it 'returns an array containing empty strings' do
-        expect(coder.decode(%[{1,"",3,""}])).to eql ['1', '', '3', '']
-      end
-
-      it 'returns an array containing unicode strings' do
-        expect(coder.decode(%[{"Paragraph 399(b)(i) – “valid leave” – meaning"}])).to eq(['Paragraph 399(b)(i) – “valid leave” – meaning'])
-      end
-    end
-
-    context 'two dimensional arrays' do
-      it 'returns an empty array' do
-        expect(coder.decode(%[{{}}])).to eql [[]]
-        expect(coder.decode(%[{{},{}}])).to eql [[],[]]
-      end
-
-      it 'returns an array of strings with a sub array' do
-        expect(coder.decode(%[{1,{2,3},4}])).to eql ['1',['2','3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array' do
-        expect(coder.decode(%[{1,{"2,3"},4}])).to eql ['1',['2,3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array and a quoted }' do
-        expect(coder.decode(%[{1,{"2,}3",,NULL},4}])).to eql ['1',['2,}3',nil,nil],'4']
-      end
-
-      it 'returns an array of strings with a sub array and a quoted {' do
-        expect(coder.decode(%[{1,{"2,{3"},4}])).to eql ['1',['2,{3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array and a quoted { and escaped quote' do
-        expect(coder.decode(%[{1,{"2\\",{3"},4}])).to eql ['1',['2",{3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array with empty strings' do
-        expect(coder.decode(%[{1,{""},4,{""}}])).to eql ['1',[''],'4',['']]
-      end
-    end
-
-    context 'three dimensional arrays' do
-      it 'returns an empty array' do
-        expect(coder.decode(%[{{{}}}])).to eql [[[]]]
-        expect(coder.decode(%[{{{},{}},{{},{}}}])).to eql [[[],[]],[[],[]]]
-      end
-
-      it 'returns an array of strings with sub arrays' do
-        expect(coder.decode(%[{1,{2,{3,4}},{NULL,,6},7}])).to eql ['1',['2',['3','4']],[nil,nil,'6'],'7']
-      end
-    end
-
-    context 'record syntax' do
-      it 'returns an empty array' do
-        expect(coder.decode(%[()])).to eql []
-      end
-
-      it 'returns an array of strings' do
-        expect(coder.decode(%[(1,2,3)])).to eql ['1','2','3']
-      end
-
-      it 'returns an array of strings, with nils replacing NULL characters' do
-        expect(coder.decode(%[(1,,NULL)])).to eql ['1',nil,nil]
-      end
-
-      it 'returns an array with the word NULL' do
-        expect(coder.decode(%[(1,"NULL",3)])).to eql ['1','NULL','3']
-      end
-
-      it 'returns an array of strings when containing commas in a quoted string' do
-        expect(coder.decode(%[(1,"2,3",4)])).to eql ['1','2,3','4']
-      end
-
-      it 'returns an array of strings when containing an escaped quote' do
-        expect(coder.decode(%[(1,"2\\",3",4)])).to eql ['1','2",3','4']
-      end
-
-      it 'returns an array of strings when containing an escaped backslash' do
-        expect(coder.decode(%[(1,"2\\\\",3,4)])).to eql ['1','2\\','3','4']
-        expect(coder.decode(%[(1,"2\\\\\\",3",4)])).to eql ['1','2\\",3','4']
-      end
-
-      it 'returns an array containing empty strings' do
-        expect(coder.decode(%[(1,"",3,"")])).to eql ['1', '', '3', '']
-      end
-
-      it 'returns an array containing unicode strings' do
-        expect(coder.decode(%[("Paragraph 399(b)(i) – “valid leave” – meaning")])).to eq(['Paragraph 399(b)(i) – “valid leave” – meaning'])
-      end
-    end
-
-    context 'array of records' do
-      it 'returns an empty array' do
-        expect(coder.decode(%[{()}])).to eql [[]]
-        expect(coder.decode(%[{(),()}])).to eql [[],[]]
-      end
-
-      it 'returns an array of strings with a sub array' do
-        expect(coder.decode(%[{1,(2,3),4}])).to eql ['1',['2','3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array' do
-        expect(coder.decode(%[{1,("2,3"),4}])).to eql ['1',['2,3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array and a quoted }' do
-        expect(coder.decode(%[{1,("2,}3",,NULL),4}])).to eql ['1',['2,}3',nil,nil],'4']
-      end
-
-      it 'returns an array of strings with a sub array and a quoted {' do
-        expect(coder.decode(%[{1,("2,{3"),4}])).to eql ['1',['2,{3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array and a quoted { and escaped quote' do
-        expect(coder.decode(%[{1,("2\\",{3"),4}])).to eql ['1',['2",{3'],'4']
-      end
-
-      it 'returns an array of strings with a sub array with empty strings' do
-        expect(coder.decode(%[{1,(""),4,("")}])).to eql ['1',[''],'4',['']]
-      end
-    end
-
-    context 'mix of record and array' do
-      it 'returns an empty array' do
-        expect(coder.decode(%[({()})])).to eql [[[]]]
-        expect(coder.decode(%[{({},{}),{(),{}}}])).to eql [[[],[]],[[],[]]]
-      end
-
-      it 'returns an array of strings with sub arrays' do
-        expect(coder.decode(%[{1,(2,{3,4}),(NULL,,6),7}])).to eql ['1',['2',['3','4']],[nil,nil,'6'],'7']
-      end
-    end
-
-    context 'record complex sample' do
-      it 'may have double double quotes translate to single double quotes' do
-        expect(coder.decode(%[("Test with double "" quoutes")])).to eql ['Test with double " quoutes']
-      end
-
-      it 'double double quotes may occur any number of times' do
-        expect(coder.decode(%[("Only one ""","Now "" two "".",""",""{""}","""""")])).to eql ['Only one "', 'Now " two ".', '","{"}', '""']
-      end
-
-      it 'may have any kind of value' do
-        expect(coder.decode(%[(String,123456,false,true,"2016-01-01 12:00:00",{1,2,3})])).to eql ['String', '123456', 'false', 'true', '2016-01-01 12:00:00', ['1', '2', '3']]
-      end
-    end
-
-  end
-
-  context 'on encode' do
-    let(:record) { Torque::PostgreSQL::Coder::Record }
-
-    context 'one dimensional arrays' do
-      it 'receives an empty array' do
-        expect(coder.encode([])).to eql %[{}]
-      end
-
-      it 'receives an array of strings' do
-        expect(coder.encode(['1','2','3'])).to eql %[{1,2,3}]
-      end
-
-      it 'receives an array of strings, with nils replacing NULL characters' do
-        expect(coder.encode(['1',nil,nil])).to eql %[{1,NULL,NULL}]
-      end
-
-      it 'receives an array with the word NULL' do
-        expect(coder.encode(['1','NULL','3'])).to eql %[{1,"NULL",3}]
-      end
-
-      it 'receives an array of strings when containing commas in a quoted string' do
-        expect(coder.encode(['1','2,3','4'])).to eql %[{1,"2,3",4}]
-      end
-
-      it 'receives an array of strings when containing an escaped quote' do
-        expect(coder.encode(['1','2",3','4'])).to eql %[{1,"2\\",3",4}]
-      end
-
-      it 'receives an array of strings when containing an escaped backslash' do
-        expect(coder.encode(['1','2\\','3','4'])).to eql %[{1,"2\\\\",3,4}]
-        expect(coder.encode(['1','2\\",3','4'])).to eql %[{1,"2\\\\\\",3",4}]
-      end
-
-      it 'receives an array containing empty strings' do
-        expect(coder.encode(['1', '', '3', ''])).to eql %[{1,"",3,""}]
-      end
-
-      it 'receives an array containing unicode strings' do
-        expect(coder.encode(['Paragraph 399(b)(i) – “valid leave” – meaning'])).to eql %[{"Paragraph 399(b)(i) – “valid leave” – meaning"}]
-      end
-    end
-
-    context 'two dimensional arrays' do
-      it 'receives an empty array' do
-        expect(coder.encode([[]])).to eql %[{{}}]
-        expect(coder.encode([[],[]])).to eql %[{{},{}}]
-      end
-
-      it 'receives an array of strings with a sub array' do
-        expect(coder.encode(['1',['2','3'],'4'])).to eql %[{1,{2,3},4}]
-      end
-
-      it 'receives an array of strings with a sub array' do
-        expect(coder.encode(['1',['2,3'],'4'])).to eql %[{1,{"2,3"},4}]
-      end
-
-      it 'receives an array of strings with a sub array and a quoted }' do
-        expect(coder.encode(['1',['2,}3',nil,nil],'4'])).to eql %[{1,{"2,}3",NULL,NULL},4}]
-      end
-
-      it 'receives an array of strings with a sub array and a quoted {' do
-        expect(coder.encode(['1',['2,{3'],'4'])).to eql %[{1,{"2,{3"},4}]
-      end
-
-      it 'receives an array of strings with a sub array and a quoted { and escaped quote' do
-        expect(coder.encode(['1',['2",{3'],'4'])).to eql %[{1,{"2\\",{3"},4}]
-      end
-
-      it 'receives an array of strings with a sub array with empty strings' do
-        expect(coder.encode(['1',[''],'4',['']])).to eql %[{1,{""},4,{""}}]
-      end
-    end
-
-    context 'three dimensional arrays' do
-      it 'receives an empty array' do
-        expect(coder.encode([[[]]])).to eql %[{{{}}}]
-        expect(coder.encode([[[],[]],[[],[]]])).to eql %[{{{},{}},{{},{}}}]
-      end
-
-      it 'receives an array of strings with sub arrays' do
-        expect(coder.encode(['1',['2',['3','4']],[nil,nil,'6'],'7'])).to eql %[{1,{2,{3,4}},{NULL,NULL,6},7}]
-      end
-    end
-
-    context 'record syntax' do
-      it 'receives an empty array' do
-        expect(coder.encode( record.new )).to eql %[()]
-      end
-
-      it 'receives an array of strings' do
-        expect(coder.encode( record.new(['1','2','3']) )).to eql %[(1,2,3)]
-      end
-
-      it 'receives an array of strings, with nils replacing NULL characters' do
-        expect(coder.encode( record.new(['1',nil,nil]) )).to eql %[(1,,)]
-      end
-
-      it 'receives an array with the word NULL' do
-        expect(coder.encode( record.new(['1','NULL','3']) )).to eql %[(1,"NULL",3)]
-      end
-
-      it 'receives an array of strings when containing commas in a quoted string' do
-        expect(coder.encode( record.new(['1','2,3','4']) )).to eql %[(1,"2,3",4)]
-      end
-
-      it 'receives an array of strings when containing an escaped quote' do
-        expect(coder.encode( record.new(['1','2",3','4']) )).to eql %[(1,"2\\",3",4)]
-      end
-
-      it 'receives an array of strings when containing an escaped backslash' do
-        expect(coder.encode( record.new(['1','2\\','3','4']) )).to eql %[(1,"2\\\\",3,4)]
-        expect(coder.encode( record.new(['1','2\\",3','4']) )).to eql %[(1,"2\\\\\\",3",4)]
-      end
-
-      it 'receives an array containing empty strings' do
-        expect(coder.encode( record.new(['1', '', '3', '']) )).to eql %[(1,"",3,"")]
-      end
-
-      it 'receives an array containing unicode strings' do
-        expect(coder.encode( record.new(['Paragraph 399(b)(i) – “valid leave” – meaning']) )).to eql %[("Paragraph 399(b)(i) – “valid leave” – meaning")]
-      end
-    end
-
-    context 'array of records' do
-      it 'receives an empty array' do
-        expect(coder.encode([record.new])).to eql %[{()}]
-        expect(coder.encode([record.new,record.new])).to eql %[{(),()}]
-      end
-
-      it 'receives an array of strings with a sub array' do
-        expect(coder.encode(['1',record.new(['2','3']),'4'])).to eql %[{1,(2,3),4}]
-      end
-
-      it 'receives an array of strings with a sub array' do
-        expect(coder.encode(['1',record.new(['2,3']),'4'])).to eql %[{1,("2,3"),4}]
-      end
-
-      it 'receives an array of strings with a sub array and a quoted }' do
-        expect(coder.encode(['1',record.new(['2,}3',nil,nil]),'4'])).to eql %[{1,("2,}3",,),4}]
-      end
-
-      it 'receives an array of strings with a sub array and a quoted {' do
-        expect(coder.encode(['1',record.new(['2,{3']),'4'])).to eql %[{1,("2,{3"),4}]
-      end
-
-      it 'receives an array of strings with a sub array and a quoted { and escaped quote' do
-        expect(coder.encode(['1',record.new(['2",{3']),'4'])).to eql %[{1,("2\\",{3"),4}]
-      end
-
-      it 'receives an array of strings with a sub array with empty strings' do
-        expect(coder.encode(['1',record.new(['']),'4',record.new([''])])).to eql %[{1,(""),4,("")}]
-      end
-    end
-
-    context 'mix of record and array' do
-      it 'receives an empty array' do
-        expect(coder.encode( record.new([[record.new,nil]]) )).to eql %[({(),NULL})]
-        expect(coder.encode( [record.new([[], []]),[record.new,[]]] )).to eql %[{({},{}),{(),{}}}]
-      end
-
-      it 'receives an array of strings with sub arrays' do
-        expect(coder.encode(['1',record.new(['2',['3','4']]),record.new([nil,nil,'6']),'7'])).to eql %[{1,(2,{3,4}),(,,6),7}]
-      end
-    end
-
-    context 'record complex sample' do
-      it 'may have double double quotes translate to single double quotes' do
-        expect(coder.encode( record.new(['Test with double " quoutes']) )).to eql %[("Test with double \\" quoutes")]
-      end
-
-      it 'double double quotes may occur any number of times' do
-        expect(coder.encode( record.new(['Only one "', 'Now " two ".', '","{"}', '""']) )).to eql %[("Only one \\"","Now \\" two \\".","\\",\\"{\\"}","\\"\\"")]
-      end
-
-      it 'may have any kind of value' do
-        expect(coder.encode( record.new(['String', '123456', 'false', 'true', '2016-01-01 12:00:00', ['1', '2', '3']]) )).to eql %[(String,123456,false,true,"2016-01-01 12:00:00",{1,2,3})]
-      end
-    end
-
-  end
-
-end