Merge pull request #27 from crashtech/v0214

Lunching new version

Author: Carlos

gemfiles/Gemfile.rails-5.2

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'rails', '~> 5.2.1'
+gem 'rails', '~> 5.2.2'
 gem 'pg', '~> 1.1.3'
 gem "byebug"
 

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

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

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

@@ -49,15 +49,15 @@ def cast(value)
           # 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
           # See ActiveSupport::Duration#iso8601
           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 @@ def assert_valid_value(value)
 
           # 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

lib/torque/postgresql/attributes.rb

@@ -29,7 +29,7 @@ def method_missing(method_name, *args, &block)
           # 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

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

@@ -4,15 +4,14 @@ module Attributes
       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,29 +52,24 @@ def values_methods
           # 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?))
             end
 
             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 @@ def dangerous?(method_name, class_method = false)
 
             # 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
 

lib/torque/postgresql/attributes/enum.rb

@@ -22,6 +22,17 @@ def lookup(name)
             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 @@ def members
             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 @@ def connection(name)
 
         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 @@ def i18n_keys(attr = nil, model = nil)
 
             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 @@ def raise_comparison(other)
 
       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

lib/torque/postgresql/attributes/type_map.rb

@@ -10,16 +10,47 @@ def types
             @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)
             types[key] = block
           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 @@ def present?(key)
             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