rasti-db 2.3.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 057df50ee7debeb86b2ad63d4dffc965df8941e0f19ac4d4f96fe97ca319c314
-  data.tar.gz: c0cda671e2ea8f748b59c34108440edc7e016702f4d5832efac995a650005e62
+  metadata.gz: cbeaaf85ac611e3a8a014720fca0ce2328c240e73b05cae04c4f9c9a3be6b7f6
+  data.tar.gz: 120f2ad079c6ea185bf95d4e74eec3a4d85bbb5bfb6941e8b8f923d5653c5e5f
 SHA512:
-  metadata.gz: d31034d885d8791bb04a2417372d56226c51b4fe8c54279d294148b22c68a7744f12887a948692f12e0b24c1a4abf8868b3c9250948ffb516e2c2515b42ea0aa
-  data.tar.gz: b75bc69a65eb10032f510ff5cb99cd511b69bc354c6bc3bc836e23612a0a21f9cc0a01849b752d58b1e86c0b9387adcb665ad609198495120a1da0c6fa2418a7
+  metadata.gz: a9479412975696063c5bf0d62e2f5a41d2f71afe98adb688356cd468a9dc6da04c9b02a5fcc434c8e3964d06bc1f96bfb6206fa6a8032e23587b1d68be9372b6
+  data.tar.gz: 5608471902a30b61971f03ad95e7b6d6d9fd62b8bf350d4bea55f840518e18f32201a9598f533882ee5a0c19d0634824d714fb3361f2f7fbdb976e4125819f46

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

@@ -3,62 +3,58 @@ module Rasti
     module TypeConverters
       class Postgres
 
-        CONVERTERS = [PostgresTypes::JSON, PostgresTypes::JSONB, PostgresTypes::HStore, PostgresTypes::Array]
-
-        @to_db_mapping = {}
+        CONVERTERS = [
+          PostgresTypes::JSON,
+          PostgresTypes::JSONB,
+          PostgresTypes::HStore,
+          PostgresTypes::Array
+        ]
 
         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
+            converter, type = find_to_db_converter_and_type db, collection_name, attribute_name
+            converter ? converter.to_db(value, type) : value
           end
 
-          def from_db(object)
-            if from_db_mapping.key? object.class
-              from_db_mapping[object.class].from_db object
-            else
-              object
-            end
+          def from_db(value)
+            converter = find_from_db_converter value.class
+            converter ? converter.from_db(value) : value
           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)]
+          def from_db_converters
+            @from_db_converters ||= {}
+          end
 
-              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]
+          def to_db_converters
+            @to_db_converters ||= {}
+          end
+
+          def find_to_db_converter_and_type(db, collection_name, attribute_name)
+            key = [db.opts[:database], collection_name].join('.')
 
-                    hash[name] = {converter: converter, sub_type: match.captures.first} if match
-                  end
-                end
+            to_db_converters[key] ||= begin
+              columns = Hash[db.schema(collection_name)]
+              to_db_converters[key] = columns.each_with_object({}) do |(name, schema), hash|
+                converter = CONVERTERS.detect { |c| c.to_db? schema[:db_type] }
+                hash[name] = [converter, schema[:db_type]] if converter
               end
             end
+
+            to_db_converters[key].fetch(attribute_name, [])
           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              
+          def find_from_db_converter(klass)
+            if !from_db_converters.key?(klass)
+              from_db_converters[klass] = CONVERTERS.detect { |c| c.from_db? klass }
             end
+
+            from_db_converters[klass]
           end
 
         end
-
       end
     end
   end

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

@@ -3,28 +3,30 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class Array
-
           class << self
 
-            def column_type_regex
-              /^([a-z]+)\[\]$/
+            DB_TYPE_REGEX = /^([a-z]+)\[\]$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
+              sub_type = type[0..-3]
               array = sub_type == 'hstore' ? value.map { |v| Sequel.hstore v } : value
               Sequel.pg_array array, sub_type
             end
 
-            def db_classes
-              [Sequel::Postgres::PGArray]
+            def from_db?(klass)
+              defined?(Sequel::Postgres::PGArray) &&
+              klass == Sequel::Postgres::PGArray
             end
 
-            def from_db(object)
-              object.to_a
+            def from_db(value)
+              value.to_a
             end
 
           end
-
         end
       end
     end

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

@@ -3,27 +3,28 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class HStore
-
           class << self
 
-            def column_type_regex
-              /^hstore$/
+            DB_TYPE_REGEX = /^hstore$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
               Sequel.hstore value
             end
 
-            def db_classes
-              [Sequel::Postgres::HStore]
+            def from_db?(klass)
+              defined?(Sequel::Postgres::HStore) &&
+              klass == Sequel::Postgres::HStore
             end
 
-            def from_db(object)
-              object.to_h
+            def from_db(value)
+              value.to_h
             end
 
           end
-
         end
       end
     end

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

@@ -3,36 +3,39 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class JSON
-
           class << self
 
-            def column_type_regex
-              /^json$/
+            DB_TYPE_REGEX = /^json$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
               Sequel.pg_json value
             end
 
-            def db_classes
-              @db_classes ||= from_db_convertions.keys
+            def from_db?(klass)
+              to_hash?(klass) || to_array?(klass)
             end
 
-            def from_db(object)
-              object.public_send from_db_convertions[object.class]
+            def from_db(value)
+              to_hash?(value.class) ? value.to_h : value.to_a
             end
 
             private
 
-            def from_db_convertions
-              @from_db_convertions ||= {
-                Sequel::Postgres::JSONHash => :to_h,
-                Sequel::Postgres::JSONArray => :to_a
-              }
+            def to_hash?(klass)
+              defined?(Sequel::Postgres::JSONHash) &&
+              klass == Sequel::Postgres::JSONHash
             end
 
-          end
+            def to_array?(klass)
+              defined?(Sequel::Postgres::JSONArray) &&
+              klass == Sequel::Postgres::JSONArray
+            end
 
+          end
         end
       end
     end

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

@@ -3,36 +3,39 @@ module Rasti
     module TypeConverters
       module PostgresTypes
         class JSONB
-
           class << self
 
-            def column_type_regex
-              /^jsonb$/
+            DB_TYPE_REGEX = /^jsonb$/
+
+            def to_db?(type)
+              !type.match(DB_TYPE_REGEX).nil?
             end
 
-            def to_db(value, sub_type)
+            def to_db(value, type)
               Sequel.pg_jsonb value
             end
 
-            def db_classes
-              @db_classes ||= from_db_convertions.keys
+            def from_db?(klass)
+              to_hash?(klass) || to_array?(klass)
             end
 
-            def from_db(object)
-              object.public_send from_db_convertions[object.class]
+            def from_db(value)
+              to_hash?(value.class) ? value.to_h : value.to_a
             end
 
             private
 
-            def from_db_convertions
-              @from_db_convertions ||= {
-                Sequel::Postgres::JSONBHash => :to_h,
-                Sequel::Postgres::JSONBArray => :to_a
-              }
+            def to_hash?(klass)
+              defined?(Sequel::Postgres::JSONBHash) &&
+              klass == Sequel::Postgres::JSONBHash
             end
 
-          end
+            def to_array?(klass)
+              defined?(Sequel::Postgres::JSONBArray) &&
+              klass == Sequel::Postgres::JSONBArray
+            end
 
+          end
         end
       end
     end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '2.3.0'
+    VERSION = '2.3.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-db
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.3.1
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-23 00:00:00.000000000 Z
+date: 2021-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel