torque-postgresql 0.2.16 → 1.0.0

data/lib/torque/postgresql/i18n.rb

@@ -3,7 +3,7 @@ module Torque
     module I18n
 
       # Adds extra suport to localize durations
-      # This is a temporary solution, since 3600.seconds do not translate into
+      # This is a temporary solution, since 3600.seconds does not translate into
       # 1 hour
       def localize(locale, object, format = :default, options = {})
         return super unless object.is_a?(ActiveSupport::Duration)

data/lib/torque/postgresql/railtie.rb

@@ -5,23 +5,36 @@ module Torque
 
       # Get information from the running rails app
       initializer 'torque-postgresql' do |app|
-        Torque::PostgreSQL.config.eager_load = app.config.eager_load
+        torque_config = Torque::PostgreSQL.config
+        torque_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)
+        Torque::PostgreSQL::Attributes::EnumSet.include_on(ActiveRecord::Base)
+        Torque::PostgreSQL::Attributes::Period.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|
+        # Setup belongs_to_many association
+        ActiveRecord::Base.belongs_to_many_required_by_default = torque_config.associations
+          .belongs_to_many_required_by_default
+
+        # Define a method to find enumaerators based on the namespace
+        torque_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_config.enum.namespace.define_singleton_method(:sample) do |name|
           Torque::PostgreSQL::Attributes::Enum.lookup(name).sample
         end
-      end
 
+        # Define the exposed constant for auxiliary statements
+        if torque_config.auxiliary_statement.exposed_class.present?
+          *ns, name = torque_config.auxiliary_statement.exposed_class.split('::')
+          base = ns.present? ? Object.const_get(ns.join('::')) : Object
+          base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement)
+        end
+      end
     end
   end
 end

data/lib/torque/postgresql/reflection.rb

@@ -0,0 +1,21 @@
+require_relative 'reflection/abstract_reflection'
+require_relative 'reflection/association_reflection'
+require_relative 'reflection/belongs_to_many_reflection'
+require_relative 'reflection/has_many_reflection'
+require_relative 'reflection/runtime_reflection'
+require_relative 'reflection/through_reflection'
+
+module Torque
+  module PostgreSQL
+    module Reflection
+
+      def create(macro, name, scope, options, ar)
+        return super unless macro.eql?(:belongs_to_many)
+        BelongsToManyReflection.new(name, scope, options, ar)
+      end
+
+    end
+
+    ::ActiveRecord::Reflection.singleton_class.prepend(Reflection)
+  end
+end

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

@@ -0,0 +1,109 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module AbstractReflection
+        AREL_ATTR = ::Arel::Attributes::Attribute
+
+        ARR_NO_CAST = 'bigint'.freeze
+        ARR_CAST = 'bigint[]'.freeze
+
+        # Check if the foreign key actually exists
+        def connected_through_array?
+          false
+        end
+
+        # Monkey patching for rais 5.0
+        def torque_join_keys
+          method(:join_keys).arity.eql?(0) ? join_keys : join_keys(klass)
+        end
+
+        # Manually build the join constraint
+        def build_join_constraint(table, foreign_table)
+          klass_attr = table[torque_join_keys.key]
+          source_attr = foreign_table[torque_join_keys.foreign_key]
+
+          result = build_id_constraint(klass_attr, source_attr)
+          result = table.create_and([result, klass.send(:type_condition, table)]) \
+            if klass.finder_needs_type_condition?
+
+          result
+        end
+
+        # Build the id constraint checking if both types are perfect matching
+        def build_id_constraint(klass_attr, source_attr)
+          return klass_attr.eq(source_attr) unless connected_through_array?
+
+          # Klass and key are associated with the reflection Class
+          klass_type = klass.columns_hash[torque_join_keys.key]
+          # active_record and foreign_key are associated with the source Class
+          source_type = active_record.columns_hash[torque_join_keys.foreign_key]
+
+          # If both are attributes but the left side is not an array, and the
+          # right side is, use the ANY operation
+          any_operation = arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
+          return klass_attr.eq(any_operation) if any_operation
+
+          # If the left side is not an array, just use the IN condition
+          return klass_attr.in(source_attr) unless klass_type.try(:array)
+
+          # Decide if should apply a cast to ensure same type comparision
+          should_cast = klass_type.type.eql?(:integer) && source_type.type.eql?(:integer)
+          should_cast &= !klass_type.sql_type.eql?(source_type.sql_type)
+          should_cast |= !(klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR))
+
+          # Apply necessary transformations to values
+          klass_attr = cast_constraint_to_array(klass_type, klass_attr, should_cast)
+          source_attr = cast_constraint_to_array(source_type, source_attr, should_cast)
+
+          # Return the overlap condition
+          klass_attr.overlaps(source_attr)
+        end
+
+        private
+
+          # 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)
+            return value if base_ready && (type.sql_type.eql?(ARR_NO_CAST) || !should_cast)
+
+            value = ::Arel::Nodes.build_quoted(Array.wrap(value)) unless base_ready
+            value = value.cast(ARR_CAST) if should_cast
+            value
+          end
+
+          # Check if it's possible to turn both attributes into an ANY condition
+          def arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
+            return unless !klass_type.try(:array) && source_type.try(:array) &&
+              klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR)
+
+            ::Arel::Nodes::NamedFunction.new('ANY', [source_attr])
+          end
+
+          # returns either +nil+ or the inverse association name that it finds.
+          def automatic_inverse_of
+            return super unless connected_through_array?
+            if can_find_inverse_of_automatically?(self)
+              inverse_name = options[:as] || active_record.name.demodulize
+              inverse_name = ActiveSupport::Inflector.underscore(inverse_name)
+              inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
+              inverse_name = inverse_name.to_sym
+
+              begin
+                reflection = klass._reflect_on_association(inverse_name)
+              rescue NameError
+                # Give up: we couldn't compute the klass type so we won't be able
+                # to find any associations either.
+                reflection = false
+              end
+
+              return inverse_name if reflection.connected_through_array? &&
+                valid_inverse_reflection?(reflection)
+            end
+          end
+
+      end
+
+      ::ActiveRecord::Reflection::AbstractReflection.prepend(AbstractReflection)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module AssociationReflection
+
+        def initialize(name, scope, options, active_record)
+          super
+
+          raise ArgumentError, <<-MSG.squish if options[:array] && options[:polymorphic]
+            Associations can't be connected through an array at the same time they are
+            polymorphic. Please choose one of the options.
+          MSG
+        end
+
+        private
+
+          # Check if the foreign key should be pluralized
+          def derive_foreign_key
+            result = super
+            result = ActiveSupport::Inflector.pluralize(result) \
+              if collection? && connected_through_array?
+            result
+          end
+
+      end
+
+      ::ActiveRecord::Reflection::AssociationReflection.prepend(AssociationReflection)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      class BelongsToManyReflection < ::ActiveRecord::Reflection::AssociationReflection
+        def macro
+          :belongs_to_many
+        end
+
+        def connected_through_array?
+          true
+        end
+
+        def collection?
+          true
+        end
+
+        def association_class
+          Associations::BelongsToManyAssociation
+        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
+        end
+
+        private
+
+          def derive_foreign_key
+            klass.primary_key
+          end
+
+          def derive_primary_key
+            ActiveSupport::Inflector.pluralize(klass.name.foreign_key)
+          end
+      end
+
+      ::ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS.push(:belongs_to_many)
+      ::ActiveRecord::Reflection.const_set(:BelongsToManyReflection, BelongsToManyReflection)
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module HasManyReflection
+        def connected_through_array?
+          options[:array]
+        end
+      end
+
+      ::ActiveRecord::Reflection::HasManyReflection.include(HasManyReflection)
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module RuntimeReflection
+        delegate :klass, :active_record, :connected_through_array?, :macro, :name,
+          :build_id_constraint, to: :@reflection
+      end
+
+      ::ActiveRecord::Reflection::RuntimeReflection.include(RuntimeReflection)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Torque
+  module PostgreSQL
+    module Reflection
+      module ThroughReflection
+        delegate :build_id_constraint, :connected_through_array?, to: :source_reflection
+      end
+
+      ::ActiveRecord::Reflection::ThroughReflection.include(ThroughReflection)
+    end
+  end
+end

data/lib/torque/postgresql/relation.rb

@@ -14,9 +14,14 @@ module Torque
       include Inheritance
 
       SINGLE_VALUE_METHODS = [:itself_only]
-      MULTI_VALUE_METHODS = [:distinct_on, :auxiliary_statements, :cast_records]
+      MULTI_VALUE_METHODS = [:distinct_on, :auxiliary_statements, :cast_records, :select_extra]
       VALUE_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
 
+      # :nodoc:
+      def select_extra_values; get_value(:select_extra); end
+      # :nodoc:
+      def select_extra_values=(value); set_value(:select_extra, value); end
+
       # Resolve column name when calculating models, allowing the column name to
       # be more complex while keeping the query selection quality
       def calculate(operation, column_name)
@@ -41,7 +46,7 @@ module Torque
         Array.wrap(list).map do |item|
           case item
           when String
-            ::Arel::Nodes::SqlLiteral.new(klass.send(:sanitize_sql, item.to_s))
+            ::Arel.sql(klass.send(:sanitize_sql, item.to_s))
           when Symbol
             base ? base.arel_attribute(item) : klass.arel_attribute(item)
           when Array
@@ -72,13 +77,9 @@ module Torque
 
       private
 
-        def dynamic_selection
-          @dynamic_selection ||= []
-        end
-
         def build_arel(*)
           arel = super
-          arel.project(*dynamic_selection) if select_values.blank? && dynamic_selection.any?
+          arel.project(*select_extra_values) if select_values.blank?
           arel
         end
 
@@ -134,9 +135,9 @@ module Torque
     warn_level = $VERBOSE
     $VERBOSE = nil
 
-    ActiveRecord::Relation::SINGLE_VALUE_METHODS  += Relation::SINGLE_VALUE_METHODS
-    ActiveRecord::Relation::MULTI_VALUE_METHODS   += Relation::MULTI_VALUE_METHODS
-    ActiveRecord::Relation::VALUE_METHODS         += Relation::VALUE_METHODS
+    ActiveRecord::Relation::SINGLE_VALUE_METHODS       += Relation::SINGLE_VALUE_METHODS
+    ActiveRecord::Relation::MULTI_VALUE_METHODS        += Relation::MULTI_VALUE_METHODS
+    ActiveRecord::Relation::VALUE_METHODS              += Relation::VALUE_METHODS
     ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += [:cast_records, :itself_only,
       :distinct_on, :auxiliary_statements]
 

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

@@ -17,11 +17,11 @@ module Torque
         def with!(*args)
           options = args.extract_options!
           args.each do |table|
-            instance = table.is_a?(PostgreSQL::AuxiliaryStatement) \
-              ? table.class.new(options) \
+            instance = table.is_a?(Class) && table < PostgreSQL::AuxiliaryStatement \
+              ? table.new(options) \
               : PostgreSQL::AuxiliaryStatement.instantiate(table, self, options)
-            instance.ensure_dependencies!(self)
-            self.auxiliary_statements_values |= [instance]
+
+            self.auxiliary_statements_values += [instance]
           end
 
           self
@@ -47,30 +47,23 @@ module Torque
 
           # Hook arel build to add the distinct on clause
           def build_arel(*)
-            arel = super
-            build_auxiliary_statements(arel)
-            arel
+            subqueries = build_auxiliary_statements
+            return super if subqueries.nil?
+            super.with(subqueries)
           end
 
           # Build all necessary data for auxiliary statements
-          def build_auxiliary_statements(arel)
+          def build_auxiliary_statements
             return unless self.auxiliary_statements_values.present?
-
-            columns = []
-            subqueries = self.auxiliary_statements_values.map do |klass|
-              columns << klass.columns
-              klass.build_arel(arel, self)
+            self.auxiliary_statements_values.map do |klass|
+              klass.build(self)
             end
-
-            columns.flatten!
-            arel.with(subqueries.flatten)
-            dynamic_selection.concat(columns) if columns.any?
           end
 
           # Throw an error showing that an auxiliary statement of the given
           # table name isn't defined
           def auxiliary_statement_error(name)
-            raise ArgumentError, <<-MSG.strip
+            raise ArgumentError, <<-MSG.squish
               There's no '#{name}' auxiliary statement defined for #{self.class.name}.
             MSG
           end

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

@@ -76,7 +76,7 @@ module Torque
             end
 
             columns.push(build_auto_caster_marker(arel, self.cast_records_value))
-            dynamic_selection.concat(columns) if columns.any?
+            self.select_extra_values += columns if columns.any?
           end
 
           # Build as many left outer join as necessary for each dependent table
@@ -106,7 +106,7 @@ module Torque
 
             table = ::Arel::Table.new(type_attribute.camelize.underscore)
             column = table[type_attribute].in(types)
-            ::Arel::Nodes::SqlLiteral.new(column.to_sql).as(auto_cast_attribute)
+            ::Arel.sql(column.to_sql).as(auto_cast_attribute)
           end
 
       end

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

@@ -6,7 +6,7 @@ module Torque
         def merge # :nodoc:
           super
 
-          merge_dynamic_selection
+          merge_select_extra
           merge_distinct_on
           merge_auxiliary_statements
           merge_inheritance
@@ -16,9 +16,10 @@ module Torque
 
         private
 
-          # Merge dynamic selection columns
-          def merge_dynamic_selection
-            relation.send(:dynamic_selection).concat(other.send(:dynamic_selection))
+          # Merge extra select columns
+          def merge_select_extra
+            relation.select_extra_values.concat(other.select_extra_values).uniq! \
+              if other.select_extra_values.present?
           end
 
           # Merge distinct on columns
@@ -41,9 +42,12 @@ module Torque
 
           # Merge settings related to inheritance tables
           def merge_inheritance
-            relation.itself_only_value = true if other.itself_only_value
-            relation.cast_records_value.concat(other.cast_records_value).uniq! \
-              if other.cast_records_value.present?
+            relation.itself_only_value = true if other.itself_only_value.present?
+
+            if other.cast_records_value.present?
+              relation.cast_records_value += other.cast_records_value
+              relation.cast_records_value.uniq!
+            end
           end
 
       end