torque-postgresql 1.0.1 → 1.1.0

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

@@ -24,12 +24,10 @@ module Torque
 
           # 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
+          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_sym] = builder.subtype
             end
           end
 
@@ -225,17 +223,6 @@ module Torque
             raise EnumError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end
       end
-
-      # Create the methods related to the attribute to handle the enum type
-      TypeMap.register_type Adapter::OID::Enum do |subtype, attribute, options = nil|
-        # Generate methods on self class
-        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
     end
   end
 end

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

@@ -27,13 +27,8 @@ module Torque
 
           # Provide a method on the given class to setup which enum sets will be
           # manually initialized
-          def include_on(klass)
-            method_name = Torque::PostgreSQL.config.enum.set_method
-            klass.singleton_class.class_eval do
-              define_method(method_name) do |*args, **options|
-                Torque::PostgreSQL::Attributes::TypeMap.decorate(self, args, **options)
-              end
-            end
+          def include_on(klass, method_name = nil)
+            Enum.include_on(klass, method_name || Torque::PostgreSQL.config.enum.set_method)
           end
 
           # The original Enum implementation, for individual values
@@ -146,7 +141,7 @@ module Torque
 
         # Change the inspection to show the enum name
         def inspect
-          map(&:inspect).inspect
+          "[#{map(&:inspect).join(', ')}]"
         end
 
         # Replace the setter by instantiating the value
@@ -202,7 +197,7 @@ module Torque
           # Turn all the values into their respective Enum representations
           def transform_values(values)
             values = values.first if values.size.eql?(1) && values.first.is_a?(::Enumerable)
-            values.map(&method(:instantiate))
+            values.map(&method(:instantiate)).reject(&:nil?)
           end
 
           # Check for valid '?' and '!' methods
@@ -240,17 +235,6 @@ module Torque
             raise EnumSetError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end
       end
-
-      # Create the methods related to the attribute to handle the enum type
-      TypeMap.register_type Adapter::OID::EnumSet do |subtype, attribute, options = nil|
-        # Generate methods on self class
-        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
     end
   end
 end

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

@@ -4,28 +4,14 @@ module Torque
       # For naw, period doesn't have it's own class
       module Period
         class << self
-
           # Provide a method on the given class to setup which period columns
           # will be manually initialized
-          def include_on(klass)
-            method_name = Torque::PostgreSQL.config.period.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
+          def include_on(klass, method_name = nil)
+            method_name ||= Torque::PostgreSQL.config.period.base_method
+            Builder.include_on(klass, method_name, Builder::Period)
           end
-
         end
       end
-
-      # Create the methods related to the attribute to handle the enum type
-      TypeMap.register_type Adapter::OID::Range do |subtype, attribute, options = nil|
-        # Generate methods on self class
-        builder = Builder::Period.new(self, attribute, subtype, options || {})
-        break if builder.conflicting?
-        builder.build
-      end
     end
   end
 end

data/lib/torque/postgresql/config.rb

@@ -137,19 +137,23 @@ module Torque
       # initialize model-based period features
       period.base_method = :period_for
 
+      # The default name for a threshold attribute, which will automatically
+      # enable threshold features
+      period.auto_threshold = :threshold
+
       # Define the list of methods that will be created by default while setting
       # up a new period field
       period.method_names = {
-        current_on:            '%s_on',                       # 0
-        current:               'current_%s',                  # 1
-        not_current:           'not_current_%s',              # 2
-        containing:            '%s_containing',               # 3
-        not_containing:        '%s_not_containing',           # 4
-        overlapping:           '%s_overlapping',              # 5
-        not_overlapping:       '%s_not_overlapping',          # 6
-        starting_after:        '%s_starting_after',           # 7
-        starting_before:       '%s_starting_before',          # 8
-        finishing_after:       '%s_finishing_after',          # 9
+        current_on:            '%s_on',                       # 00
+        current:               'current_%s',                  # 01
+        not_current:           'not_current_%s',              # 02
+        containing:            '%s_containing',               # 03
+        not_containing:        '%s_not_containing',           # 04
+        overlapping:           '%s_overlapping',              # 05
+        not_overlapping:       '%s_not_overlapping',          # 06
+        starting_after:        '%s_starting_after',           # 07
+        starting_before:       '%s_starting_before',          # 08
+        finishing_after:       '%s_finishing_after',          # 09
         finishing_before:      '%s_finishing_before',         # 10
 
         real_containing:       '%s_real_containing',          # 11
@@ -163,14 +167,35 @@ module Torque
         not_containing_date:   '%s_not_containing_date',      # 18
         overlapping_date:      '%s_overlapping_date',         # 19
         not_overlapping_date:  '%s_not_overlapping_date',     # 20
+        real_containing_date:  '%s_real_containing_date',     # 21
+        real_overlapping_date: '%s_real_overlapping_date',    # 22
+
+        current?:              'current_%s?',                 # 23
+        current_on?:           'current_%s_on?',              # 24
+        start:                 '%s_start',                    # 25
+        finish:                '%s_finish',                   # 26
+        real:                  'real_%s',                     # 27
+        real_start:            '%s_real_start',               # 28
+        real_finish:           '%s_real_finish',              # 29
+      }
 
-        current?:              'current_%s?',                 # 21
-        current_on?:           'current_%s_on?',              # 22
-        start:                 '%s_start',                    # 23
-        finish:                '%s_finish',                   # 24
-        real:                  'real_%s',                     # 25
-        real_start:            '%s_real_start',               # 26
-        real_finish:           '%s_real_finish',              # 27
+      # If the period is marked as direct access, without the field name,
+      # then these method names will replace the default ones
+      period.direct_method_names = {
+        current_on:          'happening_in',
+        containing:          'during',
+        not_containing:      'not_during',
+        real_containing:     'real_during',
+
+        containing_date:     'during_date',
+        not_containing_date: 'not_during_date',
+
+        current_on?:         'happening_in?',
+        start:               'start_at',
+        finish:              'finish_at',
+        real:                'real_time',
+        real_start:          'real_start_at',
+        real_finish:         'real_finish_at',
       }
 
     end

data/lib/torque/postgresql/inheritance.rb

@@ -33,7 +33,28 @@ module Torque
           @inheritance_merged_attributes ||= begin
             list = attribute_names
             list += casted_dependents.values.map(&:attribute_names)
-            list.flatten.to_set.freeze
+            list.flatten.uniq.freeze
+          end
+        end
+
+        # Get the list of attributes that can be merged while querying because
+        # they all have the same type
+        def inheritance_mergeable_attributes
+          @inheritance_mergeable_attributes ||= begin
+            base = inheritance_merged_attributes - attribute_names
+            types = base.zip(base.size.times.map { [] }).to_h
+
+            casted_dependents.values.each do |klass|
+              klass.attribute_types.each do |column, type|
+                types[column]&.push(type)
+              end
+            end
+
+            result = types.select do
+              |_, types| types.each_with_object(types.shift).all?(&:==)
+            end.keys + attribute_names
+
+            result.freeze
           end
         end
 
@@ -128,7 +149,7 @@ module Torque
             record_class = _record_class_attribute.to_s
 
             return super unless record.key?(record_class) &&
-              record[auto_cast] === true && record[record_class] != table_name
+              record.delete(auto_cast) && record[record_class] != table_name
 
             klass = casted_dependents[record[record_class]]
             raise_unable_to_cast(record[record_class]) if klass.nil?
@@ -139,8 +160,17 @@ module Torque
           # Filter the record attributes to be loaded to not included those from
           # another inherited dependent
           def filter_attributes_for_cast(record, klass)
-            remove_attrs = (inheritance_merged_attributes - klass.attribute_names)
-            record.reject!{ |attribute| remove_attrs.include?(attribute) }
+            new_record = record.slice(*klass.attribute_names)
+            table = new_record[_record_class_attribute.to_s] = klass.table_name
+
+            # Recover aliased attributes
+            (klass.attribute_names - inheritance_mergeable_attributes).each do |attribute|
+              new_record[attribute] = record["#{table}__#{attribute}"]
+            end
+
+            # Add any additional columns and replace the record with the new record data
+            new_record.merge!(record.slice(*(record.keys - inheritance_merged_attributes)))
+            record.replace(new_record)
           end
 
       end

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

@@ -18,12 +18,16 @@ module Torque
           Associations::BelongsToManyAssociation
         end
 
+        def foreign_key
+          @foreign_key ||= options[:primary_key] || derive_foreign_key.freeze
+        end
+
         def association_foreign_key
           @association_foreign_key ||= foreign_key
         end
 
         def active_record_primary_key
-          @active_record_primary_key ||= options[:primary_key] || derive_primary_key
+          @active_record_primary_key ||= options[:foreign_key] || derive_primary_key
         end
 
         private
@@ -33,12 +37,13 @@ module Torque
           end
 
           def derive_primary_key
-            ActiveSupport::Inflector.pluralize(klass.name.foreign_key)
+            "#{name.to_s.singularize}_ids"
           end
       end
 
-      ::ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS.push(:belongs_to_many)
       ::ActiveRecord::Reflection.const_set(:BelongsToManyReflection, BelongsToManyReflection)
+      ::ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS
+        .push(:belongs_to_many)
     end
   end
 end

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

@@ -68,15 +68,22 @@ module Torque
           def build_inheritances(arel)
             return unless self.cast_records_value.present?
 
+            mergeable = inheritance_mergeable_attributes
+
             columns = build_inheritances_joins(arel, self.cast_records_value)
             columns = columns.map do |column, arel_tables|
               next arel_tables.first[column] if arel_tables.size == 1
-              list = arel_tables.each_with_object(column).map(&:[])
-              ::Arel::Nodes::NamedFunction.new('COALESCE', list).as(column)
+
+              if mergeable.include?(column)
+                list = arel_tables.each_with_object(column).map(&:[])
+                ::Arel::Nodes::NamedFunction.new('COALESCE', list).as(column)
+              else
+                arel_tables.map { |table| table[column].as("#{table.left.name}__#{column}") }
+              end
             end
 
             columns.push(build_auto_caster_marker(arel, self.cast_records_value))
-            self.select_extra_values += columns if columns.any?
+            self.select_extra_values += columns.flatten if columns.any?
           end
 
           # Build as many left outer join as necessary for each dependent table

data/lib/torque/postgresql/version.rb

@@ -1,5 +1,5 @@
 module Torque
   module PostgreSQL
-    VERSION = '1.0.1'
+    VERSION = '1.1.0'
   end
 end

data/lib/torque/range.rb

@@ -16,24 +16,6 @@ module Torque
       ([min, other.min].min)..([max, other.max].max)
     end
     alias_method :|, :union
-
-    def subtract(other)
-      raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-      return if other.eql?(self)
-
-      other = intersection(other)
-      return self if other.nil?
-
-      min.eql?(other.min) ? other.max..max : min..other.min
-    end
-    alias_method :-, :subtract
-
-    def add(other)
-      raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-
-      intersection(other) ? union(other) : self
-    end
-    alias_method :+, :add
   end
 
   ::Range.include(Range)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-20 00:00:00.000000000 Z
+date: 2019-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -212,7 +212,6 @@ files:
 - lib/torque/postgresql/attributes/enum_set.rb
 - lib/torque/postgresql/attributes/lazy.rb
 - lib/torque/postgresql/attributes/period.rb
-- lib/torque/postgresql/attributes/type_map.rb
 - lib/torque/postgresql/autosave_association.rb
 - lib/torque/postgresql/auxiliary_statement.rb
 - lib/torque/postgresql/auxiliary_statement/settings.rb

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

@@ -1,82 +0,0 @@
-module Torque
-  module PostgreSQL
-    module Attributes
-      # Remove type map and add decorators direct to ActiveRecord::Base
-      module TypeMap
-
-        class << self
-
-          # Reader of the list of tyes
-          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, 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
-            return false
-          end
-
-          # Check if the given type class is registered
-          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)
-            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.squish
-              Type #{key} is already defined here: #{types[key].source_location.join(':')}
-            MSG
-          end
-        end
-      end
-    end
-  end
-end