torque-postgresql 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a161d5be06adc9e93a5888b4b16b1a07b6f4a613
-  data.tar.gz: 51c1aae61c09bfa681e02daeb523551da9ef1139
+  metadata.gz: b95a55ebfe82e5b96582da09307f1d45d62ba922
+  data.tar.gz: 38a068ec3fa7cc5aab2425a31e8ed37a49b15132
 SHA512:
-  metadata.gz: 99892a8ca40bf830e81accb0d4f15d87fbcb44697b95b4f9854a81b2e5d733c80c1a23f7312009407741ea11e7a6cb4d29acae8b03284226d618fadfbaa6a9da
-  data.tar.gz: 53e5888be0f1c89d2e30c85acc2ad350e34ad5efe6b6d899315a4cd18affe9366978d5cfd7e4ddad7843c0856ca11f7243f106d5d4ad2f538a86e2c11d5551ce
+  metadata.gz: b708c73cfcac1798474e35099570e4def16a6a51b2448ef34ce2ec5e97dd4c8d57f48fa51f18182f0405afa7eed1884b81846cb3b2e132b638c8711ee80dd72c
+  data.tar.gz: 7bab6bd30e0b3898826b20cce99ff629192ea62d772864e10a3fc141e86e5f3f27a0f9e459addc29a8a27bcbb7df17920831d0f7e7b01ac823d65f600b699530

data/lib/torque/postgresql/associations/association_scope.rb

@@ -20,6 +20,7 @@ module Torque
             # 5.2 reflection, owner
 
             reflection = args.size.eql?(2) ? args[0] : args[1]
+            puts reflection.connected_through_array?.inspect
             return super unless reflection.connected_through_array?
 
             table = args[0] if args.size > 2

data/lib/torque/postgresql/attributes.rb

@@ -4,19 +4,3 @@ require_relative 'attributes/builder'
 require_relative 'attributes/enum'
 require_relative 'attributes/enum_set'
 require_relative 'attributes/period'
-
-module Torque
-  module PostgreSQL
-    module Attributes
-      extend ActiveSupport::Concern
-
-      # Configure enum_save_on_bang behavior
-      included do
-        class_attribute :enum_save_on_bang, instance_accessor: true
-        self.enum_save_on_bang = Torque::PostgreSQL.config.enum.save_on_bang
-      end
-    end
-
-    ActiveRecord::Base.include Attributes
-  end
-end

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

@@ -5,14 +5,14 @@ module Torque
   module PostgreSQL
     module Attributes
       module Builder
-        def self.include_on(klass, method_name, builder_klass, &block)
+        def self.include_on(klass, method_name, builder_klass, **extra, &block)
           klass.define_singleton_method(method_name) do |*args, **options|
             return unless connection.table_exists?(table_name)
 
             args.each do |attribute|
               begin
                 # Generate methods on self class
-                builder = builder_klass.new(self, attribute, options)
+                builder = builder_klass.new(self, attribute, extra.merge(options))
                 builder.conflicting?
                 builder.build
 

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

@@ -5,7 +5,8 @@ module Torque
         class Enum
           VALID_TYPES = %i[enum enum_set].freeze
 
-          attr_accessor :klass, :attribute, :subtype, :options, :values, :enum_module
+          attr_accessor :klass, :attribute, :subtype, :options, :values,
+            :klass_module, :instance_module
 
           # Start a new builder of methods for enum values on ActiveRecord::Base
           def initialize(klass, attribute, options)
@@ -40,15 +41,20 @@ module Torque
 
             @values_methods = begin
               values.map do |val|
-                val   = val.tr('-', '_')
-                scope = base % val
+                key   = val.downcase.tr('- ', '__')
+                scope = base % key
                 ask   = scope + '?'
                 bang  = scope + '!'
-                [val, [scope, ask, bang]]
+                [key, [scope, ask, bang, val]]
               end.to_h
             end
           end
 
+          # Check if it's building the methods for sets
+          def set_features?
+            options[:set_features].present?
+          end
+
           # Check if any of the methods that will be created get in conflict
           # with the base class methods
           def conflicting?
@@ -56,12 +62,20 @@ module Torque
             attributes = attribute.pluralize
 
             dangerous?(attributes, true)
-            dangerous?("#{attributes}_options", true)
+            dangerous?("#{attributes}_keys", true)
             dangerous?("#{attributes}_texts", true)
+            dangerous?("#{attributes}_options", true)
             dangerous?("#{attribute}_text")
 
-            values_methods.each do |attr, list|
-              list.map(&method(:dangerous?))
+            if set_features?
+              dangerous?("has_#{attributes}", true)
+              dangerous?("has_any_#{attributes}", true)
+            end
+
+            values_methods.each do |attr, (scope, ask, bang, *)|
+              dangerous?(scope, true)
+              dangerous?(bang)
+              dangerous?(ask)
             end
           rescue Interrupt => err
             raise ArgumentError, <<-MSG.squish
@@ -73,14 +87,16 @@ module Torque
 
           # Create all methods needed
           def build
-            @enum_module = Module.new
+            @klass_module = Module.new
+            @instance_module = Module.new
 
             plural
             stringify
             all_values
+            set_scopes if set_features?
 
-            klass.include enum_module
-            klass.extend enum_module::ClassMethods
+            klass.extend klass_module
+            klass.include instance_module
           end
 
           private
@@ -96,78 +112,99 @@ module Torque
                   raise Interrupt, method_name.to_s
                 end
               end
+            rescue Interrupt => e
+              raise e if Torque::PostgreSQL.config.enum.raise_conflicting
+              type = class_method ? 'class method' : 'instance method'
+              indicator = class_method ? '.' : '#'
+
+              Torque::PostgreSQL.logger.info(<<~MSG.squish)
+                Creating #{class_method} :#{method_name} for enum.
+                Overwriting existing method #{klass.name}#{indicator}#{method_name}.
+              MSG
             end
 
             # Create the method that allow access to the list of values
             def plural
-              attr = attribute
-              enum_klass = subtype.klass
-
-              # TODO: Rewrite these as string
-              enum_module.const_set('ClassMethods', Module.new)
-              enum_module::ClassMethods.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
+              enum_klass = subtype.klass.name
+              klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{attribute.pluralize}                                  # def roles
+                  ::#{enum_klass}.values                                    #   Enum::Roles.values
+                end                                                         # end
+
+                def #{attribute.pluralize}_keys                             # def roles_keys
+                  ::#{enum_klass}.keys                                      #   Enum::Roles.keys
+                end                                                         # end
+
+                def #{attribute.pluralize}_texts                            # def roles_texts
+                  ::#{enum_klass}.members.map do |member|                   #   Enum::Roles.members do |member|
+                    member.text('#{attribute}', self)                       #     member.text('role', self)
+                  end                                                       #   end
+                end                                                         # end
+
+                def #{attribute.pluralize}_options                          # def roles_options
+                  #{attribute.pluralize}_texts.zip(::#{enum_klass}.values)  #   roles_texts.zip(Enum::Roles.values)
+                end                                                         # end
+              RUBY
+            end
 
-                # def self.statuses_options() statuses_texts.zip(statuses) end
-                define_method(attr.pluralize + '_options') do
-                  public_send(attr.pluralize + '_texts').zip(enum_klass.values)
-                end
-              end
+            # Create additional methods when the enum is a set, which needs
+            # better ways to check if values are present or not
+            def set_scopes
+              cast_type = subtype.name.chomp('[]')
+              klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def has_#{attribute.pluralize}(*values)                             # def has_roles(*values)
+                  attr = arel_attribute('#{attribute}')                             #   attr = arel_attribute('role')
+                  where(attr.contains(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.contains(::Arel.array(values, cast: 'roles')))
+                end                                                                 # end
+
+                def has_any_#{attribute.pluralize}(*values)                         # def has_roles(*values)
+                  attr = arel_attribute('#{attribute}')                             #   attr = arel_attribute('role')
+                  where(attr.overlaps(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.overlaps(::Arel.array(values, cast: 'roles')))
+                end                                                                 # end
+              RUBY
             end
 
             # Create the method that turn the attribute value into text using
             # the model scope
             def stringify
-              attr = attribute
-
-              # TODO: Rewrite these as string
-              enum_module.module_eval do
-                # def status_text() status.text('status', self) end
-                define_method("#{attr}_text") { send(attr)&.text(attr, self) }
-              end
+              instance_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{attribute}_text                      # def role_text
+                  #{attribute}.text('#{attribute}', self)  #   role.text('role', self)
+                end                                        # end
+              RUBY
             end
 
             # Create all the methods that represent actions related to the
             # attribute value
             def all_values
-              attr = attribute
-              vals = values_methods
-
-              enum_klass = subtype.klass
-              model_klass = klass
-
-              # TODO: Rewrite these as string
-              enum_module.module_eval do
-                vals.each do |val, list|
-                  # scope :disabled, -> { where(status: 'disabled') }
-                  model_klass.scope list[0], -> do
-                    where(enum_klass.scope(arel_table[attr], val))
-                  end
-
-                  # def disabled? status.disabled? end
-                  define_method(list[1]) { send(attr).public_send("#{val}?") }
-
-                  # def disabled!
-                  # changed = send(attr).public_send("#{val}!")
-                  # save! if changed && enum_save_on_bang
-                  # true
-                  define_method(list[2]) do
-                    changed = send(attr).public_send("#{val}!")
-                    return save! if changed && enum_save_on_bang
-                    true
-                  end
-                end
+              klass_content = ''
+              instance_content = ''
+              enum_klass = subtype.klass.name
+
+              values_methods.each do |key, (scope, ask, bang, val)|
+                klass_content += <<-RUBY
+                  def #{scope}                                    # def admin
+                    attr = arel_attribute('#{attribute}')         #   attr = arel_attribute('role')
+                    where(::#{enum_klass}.scope(attr, '#{val}'))  #   where(Enum::Roles.scope(attr, 'admin'))
+                  end                                             # end
+                RUBY
+
+                instance_content += <<-RUBY
+                  def #{ask}                                      # def admin?
+                    #{attribute}.#{key}?                          #   role.admin?
+                  end                                             # end
+
+                  def #{bang}                                     # admin!
+                    self.#{attribute} = '#{val}'                  #   self.role = 'admin'
+                    return unless #{attribute}_changed?           #   return unless role_changed?
+                    return save! if Torque::PostgreSQL.config.enum.save_on_bang
+                    true                                          #   true
+                  end                                             # end
+                RUBY
               end
+
+              klass_module.module_eval(klass_content)
+              instance_module.module_eval(instance_content)
             end
         end
       end

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

@@ -164,7 +164,7 @@ module Torque
             method_content = define_string_method(method_name, method_content, args)
 
             source_module = send("#{type}_module")
-            source_module.class_eval(method_content)
+            source_module.module_eval(method_content)
           end
 
           private

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

@@ -51,9 +51,14 @@ module Torque
             end
           end
 
+          # List of valus as symbols
+          def keys
+            values.map(&:to_sym)
+          end
+
           # Different from values, it returns the list of items already casted
           def members
-            values.dup.map(&method(:new))
+            values.map(&method(:new))
           end
 
           # Get the list of the values translated by I18n

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

@@ -10,7 +10,7 @@ module Torque
           include Enumerable
 
           delegate :each, to: :members
-          delegate :values, :members, :texts, :to_options, :valid?, :size,
+          delegate :values, :keys, :members, :texts, :to_options, :valid?, :size,
             :length, :connection_specification_name, to: :enum_source
 
           # Find or create the class that will handle the value
@@ -28,7 +28,10 @@ module Torque
           # Provide a method on the given class to setup which enum sets will be
           # manually initialized
           def include_on(klass, method_name = nil)
-            Enum.include_on(klass, method_name || Torque::PostgreSQL.config.enum.set_method)
+            method_name ||= Torque::PostgreSQL.config.enum.set_method
+            Builder.include_on(klass, method_name, Builder::Enum, set_features: true) do |builder|
+              defined_enums[builder.attribute.to_sym] = builder.subtype
+            end
           end
 
           # The original Enum implementation, for individual values
@@ -73,7 +76,7 @@ module Torque
 
           # Build an active record scope for a given atribute agains a value
           def scope(attribute, value)
-            attribute.contains(Array.wrap(value))
+            attribute.contains(::Arel.array(value, cast: enum_source.type_name))
           end
 
           private

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -205,9 +205,16 @@ module Torque
             end
 
             # Add the scopes defined by the reflection
+            # Possibilities:
+            # table
+            # table, foreign_klass
+            # table, foreign_table, foreign_klass
             if association.respond_to?(:join_scope)
-              args = [@query.arel_table]
-              args << base if association.method(:join_scope).arity.eql?(2)
+              arity = association.method(:join_scope).arity
+              args = [@query.arel_table, foreign_table, base]
+              args.delete_at(1) if arity <= 2 # Delete foreign_table
+              args.delete_at(1) if arity <= 1 # Delete base (foreign_klass)
+
               @query.merge(association.join_scope(*args))
             end
 

data/lib/torque/postgresql/config.rb

@@ -4,6 +4,12 @@ module Torque
 
     # Stores a version check for compatibility purposes
     AR521 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.1'))
+    AR523 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.3'))
+
+    # Use the same logger as the Active Record one
+    def self.logger
+      ActiveRecord::Base.logger
+    end
 
     # Allow nested configurations
     # :TODO: Rely on +inheritable_copy+ to make nested configurations
@@ -63,6 +69,10 @@ module Torque
       # database or not
       enum.save_on_bang = true
 
+      # Indicates if it should raise errors when a generated method would
+      # conflict with an existing one
+      enum.raise_conflicting = false
+
       # Specify the namespace of each enum type of value
       enum.namespace = ::Object.const_set('Enum', Module.new)
 

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

@@ -17,12 +17,28 @@ module Torque
           method(:join_keys).arity.eql?(0) ? join_keys : join_keys(klass)
         end
 
+        # Fix for rails 5.2.3 where the join_scope method is the one now
+        # responsible for building the join condition
+        if Torque::PostgreSQL::AR523
+          def join_scope(table, foreign_table, foreign_klass)
+            return super unless connected_through_array?
+
+            predicate_builder = predicate_builder(table)
+            scope_chain_items = join_scopes(table, predicate_builder)
+            klass_scope       = klass_join_scope(table, predicate_builder)
+
+            klass_scope.where!(build_id_constraint_between(table, foreign_table))
+            klass_scope.where!(type => foreign_klass.polymorphic_name) if type
+            klass_scope.where!(klass.send(:type_condition, table)) \
+              if klass.finder_needs_type_condition?
+
+            scope_chain_items.inject(klass_scope, &:merge!)
+          end
+        end
+
         # Manually build the join constraint
         def build_join_constraint(table, foreign_table)
-          klass_attr = table[torque_join_keys.key.to_s]
-          source_attr = foreign_table[torque_join_keys.foreign_key.to_s]
-
-          result = build_id_constraint(klass_attr, source_attr)
+          result = build_id_constraint_between(table, foreign_table)
           result = table.create_and([result, klass.send(:type_condition, table)]) \
             if klass.finder_needs_type_condition?
 
@@ -61,6 +77,13 @@ module Torque
 
         private
 
+          def build_id_constraint_between(table, foreign_table)
+            klass_attr  = table[torque_join_keys.key.to_s]
+            source_attr = foreign_table[torque_join_keys.foreign_key.to_s]
+
+            build_id_constraint(klass_attr, source_attr)
+          end
+
           # Prepare a value for an array constraint overlap condition
           def cast_constraint_to_array(type, value, should_cast)
             base_ready = type.try(:array) && value.is_a?(AREL_ATTR)

data/lib/torque/postgresql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-03 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails