rasti-db 0.4.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25e0bbb3407cfae9d3217b22dff5f9756f451d2c
-  data.tar.gz: 8e92b0f310f1a7761e62b288cf3482b788f6c89c
+  metadata.gz: 01b5188397b357e5b8414eebd556115131bb8c46
+  data.tar.gz: 84d1beb743f8a8ff07247724013bb8c0f9394ede
 SHA512:
-  metadata.gz: 6ce81a8a43cba1212c251d86a7cd32293c649059b0b1674bfb83fbc845cd4f9376ca2cd5f89046eecf26b69c63ce624f255a9f62f67511afca7e86d308eea985
-  data.tar.gz: f61e038f876cb4064fb75b61d2141eda0d013d17841d6b6b1e3933564e147c5a75d35df0f9595e42a7adebd0456e8b8ae7280f07cb1860fd58aa67e9f44a0a03
+  metadata.gz: 10563c028636028583d1205b0c999ad82e5281180ba16367442b1f5804510b09184db8930145e9937e2a82e675879aa9f56a8eea8f399ab6346eb6f40a6df1eb
+  data.tar.gz: a8ba4affb905f24c39cfab601b51cd263ccf2ab3c34c22494e4fc53475e96530e73df7e2759af381e7d1f2f288b2f168408432138a37042b40823a1697c64a46

data/.travis.yml

@@ -1,15 +1,15 @@
 language: ruby
 
 rvm:
-  - 1.9.3
   - 2.0
   - 2.1
   - 2.2
   - 2.3.0
   - 2.4.0
   - 2.5.0
-  - jruby-1.7.25
+  - 2.6.0
   - jruby-9.1.7.0
+  - jruby-9.1.16.0
   - ruby-head
   - jruby-head
 
@@ -19,5 +19,9 @@ matrix:
     - rvm: ruby-head
     - rvm: jruby-head
 
+jdk:
+  - openjdk8
+
 before_install:
-  - gem install bundler
+  - rvm all-gemsets do gem uninstall bundler -ax || true
+  - gem install bundler -v "< 2"

data/lib/rasti/db/collection.rb

@@ -2,8 +2,9 @@ module Rasti
   module DB
     class Collection
 
-      QUERY_METHODS = (Query::DATASET_CHAINED_METHODS + [:graph, :count, :all, :first, :pluck, :primary_keys, :any?, :empty?, :raw]).freeze
+      QUERY_METHODS = (Query::DATASET_CHAINED_METHODS + [:graph, :count, :all, :each, :first, :pluck, :primary_keys, :any?, :empty?, :raw]).freeze
 
+      include Enumerable
       include Helpers::WithSchema
 
       class << self
@@ -75,7 +76,7 @@ module Rasti
           queries[name] = lambda || block
           
           define_method name do |*args|
-            query.instance_exec *args, &self.class.queries[name]
+            query.instance_exec(*args, &self.class.queries[name])
           end
         end
 
@@ -94,7 +95,7 @@ module Rasti
 
       def insert(attributes)
         db.transaction do
-          db_attributes = type_converter.apply_to attributes
+          db_attributes = transform_attributes_to_db attributes
           collection_attributes, relations_primary_keys = split_related_attributes db_attributes
           primary_key = dataset.insert collection_attributes
           save_relations primary_key, relations_primary_keys
@@ -103,7 +104,7 @@ module Rasti
       end
 
       def bulk_insert(attributes, options={})
-        db_attributes = type_converter.apply_to attributes
+        db_attributes = attributes.map { |attrs| transform_attributes_to_db attrs }
         dataset.multi_insert db_attributes, options
       end
 
@@ -117,7 +118,7 @@ module Rasti
 
       def update(primary_key, attributes)
         db.transaction do
-          db_attributes = type_converter.apply_to attributes
+          db_attributes = transform_attributes_to_db attributes
           collection_attributes, relations_primary_keys = split_related_attributes db_attributes
           dataset.where(self.class.primary_key => primary_key).update(collection_attributes) unless collection_attributes.empty?
           save_relations primary_key, relations_primary_keys
@@ -126,7 +127,7 @@ module Rasti
       end
 
       def bulk_update(attributes, &block)
-        db_attributes = type_converter.apply_to attributes
+        db_attributes = transform_attributes_to_db attributes
         build_query(&block).instance_eval { dataset.update db_attributes }
         nil
       end
@@ -183,8 +184,11 @@ module Rasti
 
       private
 
-      def type_converter
-        @type_converter ||= TypeConverter.new db, qualified_collection_name
+      def transform_attributes_to_db(attributes)
+        attributes.each_with_object({}) do |(attribute_name, value), result| 
+          transformed_value = Rasti::DB.to_db db, qualified_collection_name, attribute_name, value
+          result[attribute_name] = transformed_value
+        end
       end
 
       def qualified_collection_name
@@ -235,7 +239,7 @@ module Rasti
                                                       .map(relation.target_collection_class.primary_key)
 
           target_collection = relation.target_collection_class.new db, schema
-          target_collection.delete_cascade *relations_ids unless relations_ids.empty?
+          target_collection.delete_cascade(*relations_ids) unless relations_ids.empty?
         end
       end
 

data/lib/rasti/db/model.rb

@@ -102,13 +102,9 @@ module Rasti
       attr_reader :attributes
 
       def fetch_attribute(name)
-        attributes.key?(name) ? casted_attribute(name) : raise(UninitializedAttributeError, name)
+        attributes.key?(name) ? Rasti::DB.from_db(attributes[name]) : raise(UninitializedAttributeError, name)
       end
 
-      def casted_attribute(name)
-        attributes[name].is_a?(Time) ? Timing::TimeInZone.new(attributes[name]) : attributes[name]
-      end
-      
     end
   end
 end

data/lib/rasti/db/query.rb

@@ -35,7 +35,7 @@ module Rasti
       alias_method :to_a, :all
 
       def each(&block)
-        all.each &block
+        all.each(&block)
       end
 
       DATASET_CHAINED_METHODS.each do |method|
@@ -88,7 +88,7 @@ module Rasti
       private
 
       def chainable(&block)
-        ds = instance_eval &block
+        ds = instance_eval(&block)
         Query.new collection_class, ds, relations, schema
       end
 
@@ -105,7 +105,7 @@ module Rasti
 
       def method_missing(method, *args, &block)
         if collection_class.queries.key?(method)
-          instance_exec *args, &collection_class.queries[method]
+          instance_exec(*args, &collection_class.queries[method])
         else
           super
         end

data/lib/rasti/db/type_converters/postgres.rb

@@ -0,0 +1,65 @@
+module Rasti
+  module DB
+    module TypeConverters
+      class Postgres
+
+        CONVERTERS = [PostgresTypes::JSON, PostgresTypes::JSONB, PostgresTypes::HStore, PostgresTypes::Array]
+
+        @to_db_mapping = {}
+
+        class << self
+
+          def to_db(db, collection_name, attribute_name, value)
+            to_db_mapping = to_db_mapping_for db, collection_name
+
+            if to_db_mapping.key? attribute_name
+              to_db_mapping[attribute_name][:converter].to_db value, to_db_mapping[attribute_name][:sub_type]
+            else
+              value
+            end
+          end
+
+          def from_db(object)
+            if from_db_mapping.key? object.class
+              from_db_mapping[object.class].from_db object
+            else
+              object
+            end
+          end
+
+          private
+
+          def to_db_mapping_for(db, collection_name)
+            key = [db.opts[:database], collection_name]
+            
+            @to_db_mapping[key] ||= begin
+              columns = Hash[db.schema(collection_name)]
+
+              columns.each_with_object({}) do |(name, schema), hash| 
+                CONVERTERS.each do |converter|
+                  unless hash.key? name
+                    match = converter.column_type_regex.match schema[:db_type]
+
+                    hash[name] = {converter: converter, sub_type: match.captures.first} if match
+                  end
+                end
+              end
+            end
+          end
+
+          def from_db_mapping
+            @from_db_mapping ||= begin
+              CONVERTERS.each_with_object({}) do |converter, result|
+                converter.db_classes.each do |db_class|
+                  result[db_class] = converter
+                end
+              end              
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/postgres_types/array.rb

@@ -0,0 +1,32 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module PostgresTypes
+        class Array
+
+          class << self
+
+            def column_type_regex
+              /^([a-z]+)\[\]$/
+            end
+
+            def to_db(value, sub_type)
+              array = sub_type == 'hstore' ? value.map { |v| Sequel.hstore v } : value
+              Sequel.pg_array array, sub_type
+            end
+
+            def db_classes
+              [Sequel::Postgres::PGArray]
+            end
+
+            def from_db(object)
+              object.to_a
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/postgres_types/hstore.rb

@@ -0,0 +1,31 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module PostgresTypes
+        class HStore
+
+          class << self
+
+            def column_type_regex
+              /^hstore$/
+            end
+
+            def to_db(value, sub_type)
+              Sequel.hstore value
+            end
+
+            def db_classes
+              [Sequel::Postgres::HStore]
+            end
+
+            def from_db(object)
+              object.to_h
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/postgres_types/json.rb

@@ -0,0 +1,40 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module PostgresTypes
+        class JSON
+
+          class << self
+
+            def column_type_regex
+              /^json$/
+            end
+
+            def to_db(value, sub_type)
+              Sequel.pg_json value
+            end
+
+            def db_classes
+              @db_classes ||= from_db_convertions.keys
+            end
+
+            def from_db(object)
+              object.public_send from_db_convertions[object.class]
+            end
+
+            private
+
+            def from_db_convertions
+              @from_db_convertions ||= {
+                Sequel::Postgres::JSONHash => :to_h,
+                Sequel::Postgres::JSONArray => :to_a
+              }
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/postgres_types/jsonb.rb

@@ -0,0 +1,40 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module PostgresTypes
+        class JSONB
+
+          class << self
+
+            def column_type_regex
+              /^jsonb$/
+            end
+
+            def to_db(value, sub_type)
+              Sequel.pg_jsonb value
+            end
+
+            def db_classes
+              @db_classes ||= from_db_convertions.keys
+            end
+
+            def from_db(object)
+              object.public_send from_db_convertions[object.class]
+            end
+
+            private
+
+            def from_db_convertions
+              @from_db_convertions ||= {
+                Sequel::Postgres::JSONBHash => :to_h,
+                Sequel::Postgres::JSONBArray => :to_a
+              }
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/time_in_zone.rb

@@ -0,0 +1,21 @@
+module Rasti
+  module DB
+    module TypeConverters
+      class TimeInZone
+
+        class << self
+
+          def to_db(db, collection_name, attribute_name, value)
+            value
+          end
+
+          def from_db(value)
+            value.is_a?(Time) ? Timing::TimeInZone.new(value) : value
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '0.4.1'
+    VERSION = '1.0.0'
   end
 end

data/lib/rasti/db.rb

@@ -2,6 +2,7 @@ require 'sequel'
 require 'consty'
 require 'time'
 require 'timing'
+require 'class_config'
 
 require_relative 'db/version'
 require_relative 'db/helpers'
@@ -14,4 +15,31 @@ require_relative 'db/relations/many_to_one'
 require_relative 'db/relations/many_to_many'
 require_relative 'db/collection'
 require_relative 'db/model'
-require_relative 'db/type_converter'
+require_relative 'db/type_converters/time_in_zone'
+require_relative 'db/type_converters/postgres_types/array'
+require_relative 'db/type_converters/postgres_types/hstore'
+require_relative 'db/type_converters/postgres_types/json'
+require_relative 'db/type_converters/postgres_types/jsonb'
+require_relative 'db/type_converters/postgres'
+
+module Rasti
+  module DB
+    
+    extend ClassConfig
+
+    attr_config :type_converters, []
+
+    def self.to_db(db, collection_name, attribute_name, value)
+      type_converters.inject(value) do |result, type_converter|
+        type_converter.to_db db, collection_name, attribute_name, result
+      end
+    end
+
+    def self.from_db(value)
+      type_converters.inject(value) do |result, type_converter|
+        type_converter.from_db result
+      end
+    end
+
+  end
+end

data/rasti-db.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'sequel', '~> 5.0'
   spec.add_runtime_dependency 'consty', '~> 1.0', '>= 1.0.3'
   spec.add_runtime_dependency 'timing', '~> 0.1', '>= 0.1.3'
+  spec.add_runtime_dependency 'class_config', '~> 0.0', '>= 0.0.2'
 
   spec.add_development_dependency 'bundler', '~> 1.12'
   spec.add_development_dependency 'rake', '~> 11.0'

data/spec/collection_spec.rb

@@ -254,6 +254,12 @@ describe 'Collection' do
       users.all.must_equal [User.new(id: id, name: 'User 1')]
     end
 
+    it 'Map' do
+      1.upto(2) { |i| db[:users].insert name: "User #{i}" }
+
+      users.map(&:name).sort.must_equal ['User 1', 'User 2']
+    end
+
     it 'First' do
       1.upto(10) { |i| db[:users].insert name: "User #{i}" }
 

data/spec/minitest_helper.rb

@@ -8,6 +8,10 @@ require 'sequel/extensions/pg_hstore'
 require 'sequel/extensions/pg_array'
 require 'sequel/extensions/pg_json'
 
+Rasti::DB.configure do |config|
+  config.type_converters = [Rasti::DB::TypeConverters::TimeInZone]
+end
+
 User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
 Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
 Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post]
@@ -68,11 +72,6 @@ class People < Rasti::DB::Collection
 end
 
 
-Rasti::DB::TypeConverter::CONVERTIONS[:sqlite] = {
-  Regexp.new('integer') => ->(value, match) { value.to_i }
-}
-
-
 class Minitest::Spec
 
   let(:users) { Users.new db }

data/spec/model_spec.rb

@@ -28,12 +28,6 @@ describe 'Model' do
       proc { post.invalid_method }.must_raise NoMethodError
     end
 
-    it 'Time conversion' do
-      person = Person.new birth_date: Time.parse('2019-01-07T11:00:00-03:00')
-
-      person.birth_date.must_be_instance_of Timing::TimeInZone      
-    end
-
   end
 
 

data/spec/type_converters/postgres_spec.rb

@@ -0,0 +1,229 @@
+require 'minitest_helper'
+
+describe Rasti::DB::TypeConverters::Postgres do
+
+  let(:type_converter) { Rasti::DB::TypeConverters::Postgres }
+
+  let(:pg) do
+    Object.new.tap do |pg|
+
+      def pg.opts
+        {
+          database: 'database'
+        }
+      end
+
+      def pg.schema(table_name, opts={})
+        [
+          [:hash,          {db_type: 'hstore'}],
+          [:text_array,    {db_type: 'text[]'}],
+          [:integer_array, {db_type: 'integer[]'}],
+          [:hstore_array,  {db_type: 'hstore[]'}],
+          [:json,          {db_type: 'json'}],
+          [:jsonb,         {db_type: 'jsonb'}]
+        ]
+      end
+
+    end
+  end
+
+  describe 'Default' do
+
+    it 'must not change value in to_db if column not found in mapping' do
+      string = type_converter.to_db pg, :table_name, :column, "hola"
+
+      string.class.must_equal String
+      string.must_equal "hola"
+    end
+
+    it 'must not change value in from_db if class not found in mapping' do
+      string = type_converter.from_db "hola"
+
+      string.class.must_equal String
+      string.must_equal "hola"
+    end
+
+  end
+
+
+  describe 'HStore' do
+
+    describe 'To DB' do
+      
+      it 'must transform Hash to HStore' do
+        hstore = type_converter.to_db pg, :table_name, :hash, {key_1: 1, key_2: 2}
+
+        hstore.class.must_equal Sequel::Postgres::HStore
+        hstore.must_equal 'key_1' => '1', 'key_2' => '2'
+      end
+
+      it 'must transform empty hash to HStore' do
+        hstore = type_converter.to_db pg, :table_name, :hash, {}
+
+        hstore.class.must_equal Sequel::Postgres::HStore
+        hstore.must_be_empty
+      end
+
+    end
+
+    describe 'From DB' do
+
+      it 'must transform HStore to Hash' do
+        hstore = Sequel::Postgres::HStore.new 'key_1' => '1', 'key_2' => '2'
+        hash = type_converter.from_db hstore
+        
+        hash.class.must_equal Hash
+        hash.must_equal hstore
+      end
+
+    end
+
+  end
+
+  describe 'Array' do
+
+    describe 'To DB' do
+
+      it 'must transform String[] to PGArray' do
+        pg_array = type_converter.to_db pg, :table_name, :text_array, %w(a b c)
+
+        pg_array.class.must_equal Sequel::Postgres::PGArray
+        pg_array.array_type.must_equal 'text'
+        pg_array.must_equal %w(a b c)
+      end
+
+      it 'must transform Integer[] to PGArray' do
+        pg_array = type_converter.to_db pg, :table_name, :integer_array, [1,2,3]
+
+        pg_array.class.must_equal Sequel::Postgres::PGArray
+        pg_array.array_type.must_equal 'integer'
+        pg_array.must_equal [1,2,3]
+      end
+
+      it 'must transform Hstore[] to PGArray' do
+        pg_array = type_converter.to_db pg, :table_name, :hstore_array, [{key: 0}, {key: 1}]
+
+        pg_array.class.must_equal Sequel::Postgres::PGArray
+        pg_array.array_type.must_equal 'hstore'
+        
+        pg_array.each_with_index do |element, index|
+          element.class.must_equal Sequel::Postgres::HStore
+          element.must_equal 'key' => index.to_s
+        end
+      end
+
+      it 'Must transform empty array to PGArray' do
+        pg_array = type_converter.to_db pg, :table_name, :integer_array, []
+
+        pg_array.class.must_equal Sequel::Postgres::PGArray
+        pg_array.array_type.must_equal 'integer'
+        pg_array.must_be_empty
+      end
+    
+    end
+
+    describe 'From DB' do
+
+      it 'must transform PGArray to Array' do
+        pg_array = Sequel::Postgres::PGArray.new [1,2,3]
+        array = type_converter.from_db pg_array
+
+        array.class.must_equal Array
+        array.must_equal pg_array
+      end
+
+    end
+
+  end
+  
+  describe 'JSON' do
+
+    let(:json_hash) { {key_1: {key_2: [3]}} }
+    let(:json_array) { [{key_1: {key_2: [3]}}] }
+
+    describe 'To DB' do
+
+      it 'must transform Hash to JSONHash' do
+        pg_json_hash = type_converter.to_db pg, :table_name, :json, json_hash
+
+        pg_json_hash.class.must_equal Sequel::Postgres::JSONHash
+        pg_json_hash.must_equal json_hash
+      end
+
+      it 'must transform Array to JSONArray' do
+        pg_json_array = type_converter.to_db pg, :table_name, :json, json_array
+
+        pg_json_array.class.must_equal Sequel::Postgres::JSONArray
+        pg_json_array.must_equal json_array
+      end
+
+    end
+
+    describe 'From DB' do
+
+      it 'must transform JSONHash to Hash' do
+        pg_json_hash = Sequel::Postgres::JSONHash.new json_hash
+        hash = type_converter.from_db pg_json_hash
+
+        hash.class.must_equal Hash
+        hash.must_equal pg_json_hash
+      end
+
+      it 'must transform JSONArray to Array' do
+        pg_json_array = Sequel::Postgres::JSONArray.new json_array
+        array = type_converter.from_db pg_json_array
+
+        array.class.must_equal Array
+        array.must_equal pg_json_array
+      end
+
+    end
+
+  end
+
+  describe 'JSONB' do
+
+    let(:json_hash) { {key_1: {key_2: [3]}} }
+    let(:json_array) { [{key_1: {key_2: [3]}}] }
+
+    describe 'To DB' do
+
+      it 'must transform Hash to JSONBHash' do
+        pg_jsonb_hash = type_converter.to_db pg, :table_name, :jsonb, json_hash
+
+        pg_jsonb_hash.class.must_equal Sequel::Postgres::JSONBHash
+        pg_jsonb_hash.must_equal json_hash
+      end
+
+      it 'must transform Array to JSONBArray' do
+        pg_jsonb_array = type_converter.to_db pg, :table_name, :jsonb, json_array
+
+        pg_jsonb_array.class.must_equal Sequel::Postgres::JSONBArray
+        pg_jsonb_array.must_equal json_array
+      end
+
+    end
+
+    describe 'From DB' do
+
+      it 'must transform JSONBHash to Hash' do
+        pg_jsonb_hash = Sequel::Postgres::JSONBHash.new json_hash
+        hash = type_converter.from_db pg_jsonb_hash
+
+        hash.class.must_equal Hash
+        hash.must_equal pg_jsonb_hash
+      end
+
+      it 'must transform JSONBArray to Array' do
+        pg_jsonb_array = Sequel::Postgres::JSONBArray.new json_array
+        array = type_converter.from_db pg_jsonb_array
+
+        array.class.must_equal Array
+        array.must_equal pg_jsonb_array
+      end
+
+    end
+
+  end
+
+end

data/spec/type_converters/time_in_zone_spec.rb

@@ -0,0 +1,33 @@
+require 'minitest_helper'
+
+describe Rasti::DB::TypeConverters::TimeInZone do
+
+  let(:type_converter) { Rasti::DB::TypeConverters::TimeInZone }
+
+  describe 'To DB' do
+
+    it 'must not transform Time to TimeInZone' do
+      time = Time.now
+
+      converted_time = type_converter.to_db db, 'table', :time, time
+
+      converted_time.class.must_equal Time
+      converted_time.must_equal time
+    end
+
+  end
+
+  describe 'From DB' do
+
+    it 'must transform Time to TimeInZone' do
+      time = Time.now
+
+      converted_time = type_converter.from_db time
+
+      converted_time.class.must_equal Timing::TimeInZone
+      converted_time.must_equal time
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-db
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-07 00:00:00.000000000 Z
+date: 2019-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -64,6 +64,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: class_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -218,7 +238,12 @@ files:
 - lib/rasti/db/relations/many_to_one.rb
 - lib/rasti/db/relations/one_to_many.rb
 - lib/rasti/db/relations/one_to_one.rb
-- lib/rasti/db/type_converter.rb
+- lib/rasti/db/type_converters/postgres.rb
+- lib/rasti/db/type_converters/postgres_types/array.rb
+- lib/rasti/db/type_converters/postgres_types/hstore.rb
+- lib/rasti/db/type_converters/postgres_types/json.rb
+- lib/rasti/db/type_converters/postgres_types/jsonb.rb
+- lib/rasti/db/type_converters/time_in_zone.rb
 - lib/rasti/db/version.rb
 - rasti-db.gemspec
 - spec/collection_spec.rb
@@ -227,7 +252,8 @@ files:
 - spec/model_spec.rb
 - spec/query_spec.rb
 - spec/relations_spec.rb
-- spec/type_converter_spec.rb
+- spec/type_converters/postgres_spec.rb
+- spec/type_converters/time_in_zone_spec.rb
 homepage: https://github.com/gabynaiman/rasti-db
 licenses:
 - MIT
@@ -259,4 +285,5 @@ test_files:
 - spec/model_spec.rb
 - spec/query_spec.rb
 - spec/relations_spec.rb
-- spec/type_converter_spec.rb
+- spec/type_converters/postgres_spec.rb
+- spec/type_converters/time_in_zone_spec.rb

data/lib/rasti/db/type_converter.rb

@@ -1,53 +0,0 @@
-module Rasti
-  module DB
-    class TypeConverter
-
-      CONVERTIONS = {
-        postgres: {
-          /^json$/         => ->(value, match) { Sequel.pg_json value },
-          /^jsonb$/        => ->(value, match) { Sequel.pg_jsonb value },
-          /^hstore$/       => ->(value, match) { Sequel.hstore value },
-          /^hstore\[\]$/   => ->(value, match) { Sequel.pg_array value.map { |v| Sequel.hstore v }, 'hstore' },
-          /^([a-z]+)\[\]$/ => ->(value, match) { Sequel.pg_array value, match.captures[0] }
-        }
-      }
-
-      def initialize(db, collection_name)
-        @db = db
-        @collection_name = collection_name
-      end
-
-      def apply_to(attributes)
-        convertions = self.class.convertions_for @db, @collection_name
-
-        return attributes if convertions.empty?
-
-        (attributes.is_a?(Array) ? attributes : [attributes]).each do |attrs|
-          convertions.each do |name, convertion|
-            attrs[name] = convertion[:block].call attrs[name], convertion[:match] if attrs.key? name
-          end
-        end
-
-        attributes
-      end
-
-      @cache ||= {}
-
-      def self.convertions_for(db, collection_name)
-        key = [db.database_type, collection_name]
-        if !@cache.key?(key)
-          columns = Hash[db.schema(collection_name)]
-          @cache[key] = columns.each_with_object({}) do |(name, schema), hash| 
-            CONVERTIONS.fetch(db.database_type, {}).each do |type, convertion|
-              if !hash.key?(name) && match = type.match(schema[:db_type])
-                hash[name] = {match: match, block: convertion}
-              end
-            end
-          end
-        end
-        @cache[key]
-      end
-
-    end
-  end
-end

data/spec/type_converter_spec.rb

@@ -1,106 +0,0 @@
-require 'minitest_helper'
-
-describe 'Type Converter' do
-
-  it 'Apply convertion' do
-    type_converter = Rasti::DB::TypeConverter.new db, :users
-    type_converter.apply_to(id: '123', name: 'User 1').must_equal id: 123, name: 'User 1'
-  end
-
-  describe 'Postgres' do
-
-    let(:pg) do
-      Object.new.tap do |pg|
-        def pg.database_type
-          :postgres
-        end
-
-        def pg.schema(table_name, opts={})
-          [
-            [:hash,          {db_type: 'hstore'}],
-            [:text_array,    {db_type: 'text[]'}],
-            [:integer_array, {db_type: 'integer[]'}],
-            [:hstore_array,  {db_type: 'hstore[]'}],
-            [:json,          {db_type: 'json'}],
-            [:jsonb,         {db_type: 'jsonb'}]
-          ]
-        end
-      end
-    end
-
-    let(:type_converter) { Rasti::DB::TypeConverter.new pg, :table_name }
-
-    it 'HStore' do
-      attributes = type_converter.apply_to hash: {key_1: 1, key_2: 2}
-
-      attributes[:hash].class.must_equal Sequel::Postgres::HStore
-      attributes[:hash].must_equal 'key_1' => '1', 'key_2' => '2'
-    end
-
-    it 'Empty hstore' do
-      attributes = type_converter.apply_to hash: {}
-
-      attributes[:hash].class.must_equal Sequel::Postgres::HStore
-      attributes[:hash].must_equal Hash.new
-    end
-
-    it 'Text array' do
-      attributes = type_converter.apply_to text_array: %w(a b c)
-
-      attributes[:text_array].class.must_equal Sequel::Postgres::PGArray
-      attributes[:text_array].array_type.must_equal 'text'
-      attributes[:text_array].must_equal %w(a b c)
-    end
-    
-    it 'Integer array' do
-      attributes = type_converter.apply_to integer_array: [1,2,3]
-
-      attributes[:integer_array].class.must_equal Sequel::Postgres::PGArray
-      attributes[:integer_array].array_type.must_equal 'integer'
-      attributes[:integer_array].must_equal [1,2,3]
-    end
-
-    it 'Hstore array' do
-      attributes = type_converter.apply_to hstore_array: [{key: 0}, {key: 1}]
-
-      attributes[:hstore_array].class.must_equal Sequel::Postgres::PGArray
-      attributes[:hstore_array].array_type.must_equal 'hstore'
-      
-      2.times do |i|
-        attributes[:hstore_array][i].class.must_equal Sequel::Postgres::HStore
-        attributes[:hstore_array][i].must_equal 'key' => i.to_s
-      end
-    end
-
-    it 'Empty array' do
-      attributes = type_converter.apply_to integer_array: []
-
-      attributes[:integer_array].class.must_equal Sequel::Postgres::PGArray
-      attributes[:integer_array].array_type.must_equal 'integer'
-      attributes[:integer_array].must_equal []
-    end
-
-    it 'Json' do
-      attributes = type_converter.apply_to json: {key_1: {key_2: [3]}}
-
-      attributes[:json].class.must_equal Sequel::Postgres::JSONHash
-      attributes[:json].must_equal key_1: {key_2: [3]}
-    end
-
-    it 'Json array' do
-      attributes = type_converter.apply_to json: [{key_1: {key_2: [3]}}]
-
-      attributes[:json].class.must_equal Sequel::Postgres::JSONArray
-      attributes[:json].must_equal [{key_1: {key_2: [3]}}]
-    end
-
-    it 'Json binary' do
-      attributes = type_converter.apply_to jsonb: {key_1: {key_2: [3]}}
-
-      attributes[:jsonb].class.must_equal Sequel::Postgres::JSONBHash
-      attributes[:jsonb].must_equal key_1: {key_2: [3]}
-    end
-
-  end
-
-end