torque-postgresql 0.2.13 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a19c0e5178591e3b9ea84d11df0b21d34f135df
-  data.tar.gz: 06c0b78395434ae948854222ce3ad015ce55cd61
+  metadata.gz: d0ed00788be18944446039d37828775e220ab9c8
+  data.tar.gz: 1c7d9ab51f7715931944c9442a84d1798a73068a
 SHA512:
-  metadata.gz: 90146d035616baa734f5a068028b32bf5a9605539d1f58a76f8ce107b65eeeaed8e88776d6bde29460ab340667b96a14fbf0e18f196c98d805f479511a5db167
-  data.tar.gz: f5f126cf74c95a4c3ccb4d6aab8f69c82a5e37215ea79928d2bc261f819d00db8c6721e059e954c9dd353182a74794c31668630ce58dac49f6274c5a113d919f
+  metadata.gz: 993b2f4cb92a254f801db65f8ec97730e260a427e62d4cde9ea986cc6a63b813e28c4179da1ec84e6516889a0bf4e7591774468e67afaea267495a257e779533
+  data.tar.gz: a9f78472309cd8604d692f9b2128027b41e16a6d1768f4b02dbf3fd00bf80a471c0cb550566e3960da4b2be43a8cfb8ac4be725c47dddd2d25c66f9b95f2ba88

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

@@ -10,6 +10,10 @@ module Torque
             new(row['typname'])
           end
 
+          def self.auto_initialize?
+            Torque::PostgreSQL.config.enum.initializer
+          end
+
           def initialize(name)
             @name  = name
             @klass = Attributes::Enum.lookup(name)

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

@@ -49,8 +49,7 @@ module Torque
           # The value must be Integer when no precision is given
           def deserialize(value)
             return if value.blank?
-            parts = ActiveSupport::Duration::ISO8601Parser.new(value).parse!
-            parts_to_duration(parts)
+            ActiveSupport::Duration.parse(value)
           end
 
           # Uses the ActiveSupport::Duration::ISO8601Serializer
@@ -58,6 +57,7 @@ module Torque
           def serialize(value)
             return if value.blank?
             value = cast(value) unless value.is_a?(ActiveSupport::Duration)
+            value = remove_weeks(value) if value.parts.to_h.key?(:weeks)
             value.iso8601(precision: @scale)
           end
 
@@ -73,20 +73,31 @@ module Torque
 
           # Transform a list of parts into a duration object
           def parts_to_duration(parts)
-            parts = parts.to_h.with_indifferent_access.slice(*CAST_PARTS)
+            parts = parts.to_h.slice(*CAST_PARTS)
             return 0.seconds if parts.blank?
 
             seconds = 0
             parts = parts.map do |part, num|
               num = num.to_i unless num.is_a?(Numeric)
-              if num > 0
-                seconds += num.send(part).value
-                [part.to_sym, num]
-              end
+              next if num <= 0
+
+              seconds += num.send(part).value
+              [part.to_sym, num]
             end
+
             ActiveSupport::Duration.new(seconds, parts.compact)
           end
 
+          # As PostgreSQL converts weeks in duration to days, intercept duration
+          # values with weeks and turn them into days before serializing so it
+          # won't break because the following issues
+          # https://github.com/crashtech/torque-postgresql/issues/26
+          # https://github.com/rails/rails/issues/34655
+          def remove_weeks(value)
+            parts = value.parts.dup
+            parts[:days] += parts.delete(:weeks) * 7
+            ActiveSupport::Duration.new(value.seconds.to_i, parts)
+          end
         end
       end
     end

data/lib/torque/postgresql/attributes.rb

@@ -29,7 +29,7 @@ module Torque
           # Use local type map to identify attribute decorator
           def define_attribute_method(attribute)
             type = attribute_types[attribute]
-            super unless TypeMap.lookup(type, self, attribute, true)
+            super unless TypeMap.lookup(type, self, attribute)
           end
 
       end

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

@@ -4,15 +4,14 @@ module Torque
       module Builder
         class Enum
 
-          attr_accessor :klass, :attribute, :subtype, :initial, :options, :values
+          attr_accessor :klass, :attribute, :subtype, :options, :values
 
           # Start a new builder of methods for composite values on
           # ActiveRecord::Base
-          def initialize(klass, attribute, subtype, initial, options)
+          def initialize(klass, attribute, subtype, options)
             @klass     = klass
             @attribute = attribute.to_s
             @subtype   = subtype
-            @initial   = initial
             @options   = options
 
             @values    = subtype.klass.values
@@ -53,9 +52,12 @@ module Torque
           # with the base class methods
           def conflicting?
             return false if options[:force] == true
+            attributes = attribute.pluralize
 
-            dangerous?(attribute.pluralize, true)
-            dangerous?(attribute + '_text')
+            dangerous?(attributes, true)
+            dangerous?("#{attributes}_options", true)
+            dangerous?("#{attributes}_texts", true)
+            dangerous?("#{attribute}_text")
 
             values_methods.each do |attr, list|
               list.map(&method(:dangerous?))
@@ -63,19 +65,11 @@ module Torque
 
             return false
           rescue Interrupt => err
-            if !initial
-              raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ')
-                #{subtype.class.name} was not able to generate requested
-                methods because the method #{err} already exists in
-                #{klass.name}.
-              MSG
-            else
-              warn <<-MSG.strip.gsub(/\n +/, ' ')
-                #{subtype.class.name} was not able to autoload on
-                #{klass.name} because the method #{err} already exists.
-              MSG
-              return true
-            end
+            raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ')
+              #{subtype.class.name} was not able to generate requested
+              methods because the method #{err} already exists in
+              #{klass.name}.
+            MSG
           end
 
           # Create all methods needed
@@ -102,45 +96,60 @@ module Torque
 
             # Create the method that allow access to the list of values
             def plural
-              klass.singleton_class.module_eval <<-STR, __FILE__, __LINE__ + 1
-                def #{attribute.pluralize}                  # def statuses
-                  ::#{subtype.klass.name}.values            #   ::Enum::Status.values
-                end                                         # end
-              STR
+              attr = attribute
+              enum_klass = subtype.klass
+              klass.singleton_class.module_eval do
+                # def self.statuses() statuses end
+                define_method(attr.pluralize) do
+                  enum_klass.values
+                end
+
+                # def self.statuses_texts() members.map(&:text) end
+                define_method(attr.pluralize + '_texts') do
+                  enum_klass.members.map do |member|
+                    member.text(attr, self)
+                  end
+                end
+
+                # def self.statuses_options() statuses_texts.zip(statuses) end
+                define_method(attr.pluralize + '_options') do
+                  enum_klass.values
+                end
+              end
             end
 
             # Create the method that turn the attribute value into text using
             # the model scope
             def text
-              klass.module_eval <<-STR, __FILE__, __LINE__ + 1
-                def #{attribute}_text                       # def status_text
-                  #{attribute}.text('#{attribute}', self)   #   status.text('status', self)
-                end                                         # end
-              STR
+              attr = attribute
+              klass.module_eval do
+                # def status_text() status.text('status', self) end
+                define_method("#{attr}_text") { send(attr).text(attr, self) }
+              end
             end
 
             # Create all the methods that represent actions related to the
             # attribute value
             def all_values
-              values_methods.each do |val, list|
-                klass.module_eval <<-STR, __FILE__, __LINE__ + 1
-                  scope :#{list[0]}, -> do                  # scope :disabled, -> do
-                    where(#{attribute}: '#{val}')           #   where(status: 'disabled')
-                  end                                       # end
-                STR
-                klass.module_eval <<-STR, __FILE__, __LINE__ + 1
-                  def #{list[1]}                            # def disabled?
-                    #{attribute}.#{val}?                    #   status.disabled?
-                  end                                       # end
-
-                  def #{list[2]}                            # def disabled!
-                    if enum_save_on_bang                    #   if enum_save_on_bang
-                      update!(#{attribute}: '#{val}')       #     update!(status: 'disabled')
-                    else                                    #   else
-                      #{attribute}.#{val}!                  #     status.disabled!
-                    end                                     #   end
-                  end                                       # end
-                STR
+              attr = attribute
+              vals = values_methods
+              klass.module_eval do
+                vals.each do |val, list|
+                  # scope :disabled, -> { where(status: 'disabled') }
+                  scope list[0], -> { where(attr => val) }
+
+                  # def disabled? status.disabled? end
+                  define_method(list[1]) { send(attr).public_send("#{val}?") }
+
+                  # def disabled! enum_save_on_bang ? update!(status: 'disabled') : status.disabled! end
+                  define_method(list[2]) do
+                    if enum_save_on_bang
+                      update!(attr => val)
+                    else
+                      send(attr).public_send("#{val}!")
+                    end
+                  end
+                end
               end
             end
 

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

@@ -22,6 +22,17 @@ module Torque
             namespace.const_set(const, Class.new(Enum))
           end
 
+          # Provide a method on the given class to setup which enums will be
+          # manually initialized
+          def include_on(klass)
+            method_name = Torque::PostgreSQL.config.enum.base_method
+            klass.singleton_class.class_eval do
+              define_method(method_name) do |*args, **options|
+                Torque::PostgreSQL::Attributes::TypeMap.decorate(self, args, **options)
+              end
+            end
+          end
+
           # You can specify the connection name for each enum
           def connection_specification_name
             return self == Enum ? 'primary' : superclass.connection_specification_name
@@ -47,6 +58,16 @@ module Torque
             values.dup.map(&method(:new))
           end
 
+          # Get the list of the values translated by I18n
+          def texts
+            members.map(&:text)
+          end
+
+          # Get a list of values translated and ready for select
+          def to_options
+            texts.zip(values)
+          end
+
           # Fetch a value from the list
           # see https://github.com/rails/rails/blob/v5.0.0/activerecord/lib/active_record/fixtures.rb#L656
           # see https://github.com/rails/rails/blob/v5.0.0/activerecord/lib/active_record/validations/uniqueness.rb#L101
@@ -88,21 +109,6 @@ module Torque
 
         end
 
-        # Extension of the ActiveRecord::Base to initiate the enum features
-        module Base
-
-          method_name = Torque::PostgreSQL.config.enum.base_method
-          module_eval <<-STR, __FILE__, __LINE__ + 1
-            def #{method_name}(*args, **options)
-              args.each do |attribute|
-                type = attribute_types[attribute.to_s]
-                TypeMap.lookup(type, self, attribute.to_s, false, options)
-              end
-            end
-          STR
-
-        end
-
         # Override string initializer to check for a valid value
         def initialize(value)
           str_value = value.is_a?(Numeric) ? self.class.values[value.to_i] : value.to_s
@@ -171,7 +177,7 @@ module Torque
 
             if attr && model
               values[:attr] = attr
-              values[:model] = model.class.model_name.i18n_key
+              values[:model] = model.model_name.i18n_key
               list_from = :i18n_scopes
             end
 
@@ -217,32 +223,16 @@ module Torque
 
       end
 
-      # Extend ActiveRecord::Base so it can have the initializer
-      ActiveRecord::Base.extend Enum::Base
-
       # Create the methods related to the attribute to handle the enum type
-      TypeMap.register_type Adapter::OID::Enum do |subtype, attribute, initial = false, options = nil|
-        break if initial && !Torque::PostgreSQL.config.enum.initializer
-        options = {} if options.nil?
-
+      TypeMap.register_type Adapter::OID::Enum do |subtype, attribute, options = nil|
         # Generate methods on self class
-        builder = Builder::Enum.new(self, attribute, subtype, initial, options)
+        builder = Builder::Enum.new(self, attribute, subtype, options || {})
         break if builder.conflicting?
         builder.build
 
         # Mark the enum as defined
         defined_enums[attribute] = subtype.klass
       end
-
-      # Define a method to find yet to define constants
-      Torque::PostgreSQL.config.enum.namespace.define_singleton_method(:const_missing) do |name|
-        Enum.lookup(name)
-      end
-
-      # Define a helper method to get a sample value
-      Torque::PostgreSQL.config.enum.namespace.define_singleton_method(:sample) do |name|
-        Enum.lookup(name).sample
-      end
     end
   end
 end

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

@@ -10,6 +10,34 @@ module Torque
             @types ||= {}
           end
 
+          # Store which elements should be initialized
+          def decorable
+            @decorable ||= Hash.new{ |h, k| h[k] = [] }
+          end
+
+          # List of options for each individual attribute on each klass
+          def options
+            @options ||= Hash.new{ |h, k| h[k] = {} }
+          end
+
+          # Mark the list of attributes on the given class that can be decorated
+          def decorate(klass, *attributes, **set_options)
+            attributes.flatten.each do |attribute|
+              decorable[klass] << attribute.to_s
+              options[klass][attribute.to_s] = set_options.deep_dup
+            end
+          end
+
+          # Force the list of attributes on the given class to be decorated by
+          # this type mapper
+          def decorate!(klass, *attributes, **options)
+            decorate(klass, *attributes, **options)
+            attributes.flatten.map do |attribute|
+              type = klass.attribute_types[attribute.to_s]
+              lookup(type, klass, attribute.to_s)
+            end
+          end
+
           # Register a type that can be processed by a given block
           def register_type(key, &block)
             raise_type_defined(key) if present?(key)
@@ -17,9 +45,12 @@ module Torque
           end
 
           # Search for a type match and process it if any
-          def lookup(key, klass, *args)
-            return unless present?(key)
-            klass.instance_exec(key, *args, &types[key.class])
+          def lookup(key, klass, attribute, *args)
+            return unless present?(key) && decorable?(key, klass, attribute)
+
+            set_options = options[klass][attribute]
+            args.unshift(set_options) unless set_options.nil?
+            klass.instance_exec(key, attribute, *args, &types[key.class])
           rescue LocalJumpError
             # There's a bug or misbehavior that blocks being called through
             # instance_exec don't accept neither return nor break
@@ -31,6 +62,13 @@ module Torque
             types.key?(key.class)
           end
 
+          # Check whether the given attribute on the given klass is
+          # decorable by this type mapper
+          def decorable?(key, klass, attribute)
+            key.class.auto_initialize? ||
+              (decorable.key?(klass) && decorable[klass].include?(attribute.to_s))
+          end
+
           # Message when trying to define multiple types
           def raise_type_defined(key)
             raise ArgumentError, <<-MSG.strip

data/lib/torque/postgresql/inheritance.rb

@@ -87,6 +87,20 @@ module Torque
           "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
         end
 
+        # For all main purposes, physical inherited classes should have
+        # base_class as their own
+        def base_class
+          return super unless physically_inherited?
+          self
+        end
+
+        # Primary key is one exception when getting information about the class,
+        # it must returns the superclass PK
+        def primary_key
+          return super unless physically_inherited?
+          superclass.primary_key
+        end
+
         # Add an additional check to return the name of the table even when the
         # class is inherited, but only if it is a physical inheritance
         def compute_table_name

data/lib/torque/postgresql/railtie.rb

@@ -6,6 +6,20 @@ module Torque
       # Get information from the running rails app
       initializer 'torque-postgresql' do |app|
         Torque::PostgreSQL.config.eager_load = app.config.eager_load
+
+        # Include enum on ActiveRecord::Base so it can have the correct enum
+        # initializer
+        Torque::PostgreSQL::Attributes::Enum.include_on(ActiveRecord::Base)
+
+        # Define a method to find yet to define constants
+        Torque::PostgreSQL.config.enum.namespace.define_singleton_method(:const_missing) do |name|
+          Torque::PostgreSQL::Attributes::Enum.lookup(name)
+        end
+
+        # Define a helper method to get a sample value
+        Torque::PostgreSQL.config.enum.namespace.define_singleton_method(:sample) do |name|
+          Torque::PostgreSQL::Attributes::Enum.lookup(name).sample
+        end
       end
 
     end

data/lib/torque/postgresql/relation.rb

@@ -112,11 +112,24 @@ module Torque
             .inheritance.auto_cast_column_name.to_sym
         end
       end
+
+      # When a relation is created, force the attributes to be defined,
+      # 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, *)
+          super
+
+          klass.superclass.send(:relation) if klass.define_attribute_methods &&
+            klass.superclass != ActiveRecord::Base && !klass.superclass.abstract_class?
+        end
+      end
     end
 
     # Include the methos here provided and then change the constants to ensure
     # the operation of ActiveRecord Relation
     ActiveRecord::Relation.include Relation
+    ActiveRecord::Relation.prepend Relation::Initializer
 
     warn_level = $VERBOSE
     $VERBOSE = nil

data/lib/torque/postgresql/schema_cache.rb

@@ -11,7 +11,6 @@ module Torque
         @data_sources_model_names = {}
         @inheritance_dependencies = {}
         @inheritance_associations = {}
-        @cached_data_sources_size = 0
       end
 
       def initialize_dup(*) # :nodoc:
@@ -19,7 +18,30 @@ module Torque
         @data_sources_model_names = @data_sources_model_names.dup
         @inheritance_dependencies = @inheritance_dependencies.dup
         @inheritance_associations = @inheritance_associations.dup
-        @cached_data_sources_size = @cached_data_sources_size.dup
+      end
+
+      def encode_with(coder) # :nodoc:
+        super
+        coder["data_sources_model_names"] = @data_sources_model_names
+        coder["inheritance_dependencies"] = @inheritance_dependencies
+        coder["inheritance_associations"] = @inheritance_associations
+      end
+
+      def init_with(coder) # :nodoc:
+        super
+        @data_sources_model_names = coder["data_sources_model_names"]
+        @inheritance_dependencies = coder["inheritance_dependencies"]
+        @inheritance_associations = coder["inheritance_associations"]
+      end
+
+      def add(table_name, *) # :nodoc:
+        super
+
+        # Reset inheritance information when a table is added
+        if @data_sources.key?(table_name)
+          @inheritance_dependencies.clear
+          @inheritance_associations.clear
+        end
       end
 
       def clear! # :nodoc:
@@ -27,7 +49,6 @@ module Torque
         @data_sources_model_names.clear
         @inheritance_dependencies.clear
         @inheritance_associations.clear
-        @cached_data_sources_size = nil
       end
 
       def size # :nodoc:
@@ -43,12 +64,10 @@ module Torque
         @data_sources_model_names.delete name
         @inheritance_dependencies.delete name
         @inheritance_associations.delete name
-        @inheritance_cache = inheritance_cache_key
       end
 
       def marshal_dump # :nodoc:
         super + [
-          @inheritance_cache,
           @inheritance_dependencies,
           @inheritance_associations,
           @data_sources_model_names,
@@ -59,7 +78,6 @@ module Torque
         @data_sources_model_names = array.pop
         @inheritance_associations = array.pop
         @inheritance_dependencies = array.pop
-        @inheritance_cache = array.pop
         super
       end
 
@@ -143,19 +161,10 @@ module Torque
           end
         end
 
-        # Generates the cache key for inheitance information
-        def inheritance_cache_key
-          @data_sources.keys.compact.sort.join(',')
-        end
-
         # Reload information about tables inheritance and dependencies, uses a
         # cache to not perform additional checkes
         def reload_inheritance_data!
-          cache_key = inheritance_cache_key
-
-          return unless @inheritance_cache != cache_key
-          @inheritance_cache = cache_key
-
+          return if @inheritance_dependencies.present?
           @inheritance_dependencies = connection.inherited_tables
           @inheritance_associations = generate_associations
         end

data/lib/torque/postgresql/version.rb

@@ -1,5 +1,5 @@
 module Torque
   module PostgreSQL
-    VERSION = '0.2.13'
+    VERSION = '0.2.14'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.14
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-22 00:00:00.000000000 Z
+date: 2018-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails