torque-postgresql 3.4.1 → 4.0.0

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

@@ -4,6 +4,15 @@ module Torque
   module PostgreSQL
     module Associations
       module AssociationScope
+        # A customized predicate builder for array attributes that can be used
+        # standalone and changes the behavior of the blank state
+        class PredicateBuilderArray
+          include PredicateBuilder::ArrayHandler
+
+          def call_with_empty(attribute)
+            '1=0' # Does not match records with empty arrays
+          end
+        end
 
         module ClassMethods
           def get_bind_values(*)
@@ -13,45 +22,34 @@ module Torque
 
         private
 
-          # When the relation is connected through an array, intercept the
-          # condition builder and uses an overlap condition building it on
-          # +build_id_constraint+
+          # When loading a join by value (last as in we know which records to
+          # load) only has many array need to have a different behavior, so it
+          # can properly match array values
           def last_chain_scope(scope, reflection, owner)
             return super unless reflection.connected_through_array?
+            return super if reflection.macro == :belongs_to_many
 
-            keys = reflection.join_keys
-            value = transform_value(owner[keys.foreign_key])
-            constraint = build_id_constraint(reflection, keys, value, true)
+            constraint = PredicateBuilderArray.new.call_for_array(
+              reflection.array_attribute,
+              transform_value(owner[reflection.join_foreign_key]),
+            )
 
             scope.where!(constraint)
           end
 
-          # When the relation is connected through an array, intercept the
-          # condition builder and uses an overlap condition building it on
-          # +build_id_constraint+
+          # When loading a join by reference (next as in we don't know which
+          # records to load), it can take advantage of the new predicate builder
+          # to figure out the most optimal way to connect both properties
           def next_chain_scope(scope, reflection, next_reflection)
             return super unless reflection.connected_through_array?
 
-            keys = reflection.join_keys
-            foreign_table = next_reflection.aliased_table
-
-            value = foreign_table[keys.foreign_key]
-            constraint = build_id_constraint(reflection, keys, value)
+            primary_key = reflection.aliased_table[reflection.join_primary_key]
+            foreign_key = next_reflection.aliased_table[reflection.join_foreign_key]
+            constraint = PredicateBuilder::ArelAttributeHandler.call(primary_key, foreign_key)
 
             scope.joins!(join(foreign_table, constraint))
           end
 
-          # Trigger the same method on the relation which will build the
-          # constraint condition using array logics
-          def build_id_constraint(reflection, keys, value, bind_param = false)
-            table = reflection.aliased_table
-            value = Array.wrap(value).map do |value|
-              build_bind_param_for_constraint(reflection, value, keys.foreign_key)
-            end if bind_param
-
-            reflection.build_id_constraint(table[keys.key], value)
-          end
-
           # For array-like values, it needs to call the method as many times as
           # the array size
           def transform_value(value)
@@ -61,12 +59,6 @@ module Torque
               value_transformation.call(value)
             end
           end
-
-          def build_bind_param_for_constraint(reflection, value, foreign_key)
-            ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
-              foreign_key, value, reflection.klass.attribute_types[foreign_key],
-            ))
-          end
       end
 
       ::ActiveRecord::Associations::AssociationScope.singleton_class.prepend(AssociationScope::ClassMethods)

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

@@ -70,6 +70,27 @@ module Torque
           @_building_changes = nil
         end
 
+        def trigger(prefix, before_ids, after_ids)
+          removed_ids = before_ids - after_ids
+          added_ids = after_ids - before_ids
+
+          if removed_ids.any?
+            callbacks_for(method = :"#{prefix}_remove").each do |callback|
+              target_scope.find(removed_ids).each do |record|
+                callback.call(method, owner, record)
+              end
+            end
+          end
+
+          if added_ids.any?
+            callbacks_for(method = :"#{prefix}_add").each do |callback|
+              target_scope.find(added_ids).each do |record|
+                callback.call(method, owner, record)
+              end
+            end
+          end
+        end
+
         ## HAS MANY
         def handle_dependency
           case options[:dependent]
@@ -193,6 +214,10 @@ module Torque
             owner.class.columns_hash[source_attr].default
           end
 
+          def callback(*)
+            true # This is handled/trigger when the owner record actually changes
+          end
+
           ## HAS MANY
           def replace_records(*)
             build_changes(true) { super }

data/lib/torque/postgresql/associations/builder/belongs_to_many.rb

@@ -21,6 +21,7 @@ module Torque
             super
             add_touch_callbacks(model, reflection)   if reflection.options[:touch]
             add_default_callbacks(model, reflection) if reflection.options[:default]
+            add_change_callbacks(model, reflection)
           end
 
           def self.define_readers(mixin, name)
@@ -94,6 +95,21 @@ module Torque
             end
           end
 
+          def self.add_change_callbacks(model, reflection)
+            foreign_key = reflection.foreign_key
+            name = reflection.name
+
+            model.before_save ->(record) do
+              before, after = record.changes[foreign_key]
+              record.association(name).trigger(:before, before, after) if before && after
+            end
+
+            model.after_save ->(record) do
+              before, after = record.previous_changes[foreign_key]
+              record.association(name).trigger(:after, before, after) if before && after
+            end
+          end
+
           def self.add_destroy_callbacks(model, reflection)
             model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
           end

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

@@ -6,6 +6,7 @@ module Torque
       module Builder
         class Enum
           VALID_TYPES = %i[enum enum_set].freeze
+          FN = '::Torque::PostgreSQL::FN'
 
           attr_accessor :klass, :attribute, :subtype, :options, :values,
             :klass_module, :instance_module
@@ -154,15 +155,17 @@ module Torque
             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_table['#{attribute}']                                 #   attr = arel_table['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_table['#{attribute}']                                 #   attr = arel_table['role']
-                  where(attr.overlaps(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.overlaps(::Arel.array(values, cast: 'roles')))
-                end                                                                 # end
+                def has_#{attribute.pluralize}(*values)                     # def has_roles(*values)
+                  attr = arel_table['#{attribute}']                         #   attr = arel_table['role']
+                  value = #{FN}.bind_with(attr, values)                     #   value = ::Torque::PostgreSQL::FN.bind_with(attr, values)
+                  where(attr.contains(value.pg_cast('#{cast_type}[]')))     #   where(attr.contains(value.pg_cast('roles[]')))
+                end                                                         # end
+
+                def has_any_#{attribute.pluralize}(*values)                 # def has_any_roles(*values)
+                  attr = arel_table['#{attribute}']                         #   attr = arel_table['role']
+                  value = #{FN}.bind_with(attr, values)                     #   value = ::Torque::PostgreSQL::FN.bind_with(attr, values)
+                  where(attr.overlaps(value.pg_cast('#{cast_type}[]')))     #   where(attr.overlaps(value.pg_cast('roles[]')))
+                end                                                         # end
               RUBY
             end
 

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        class FullTextSearch
+          attr_accessor :klass, :attribute, :options, :klass_module,
+            :default_rank, :default_mode, :default_order, :default_language
+
+          def initialize(klass, attribute, options = {})
+            @klass = klass
+            @attribute = attribute
+            @options = options
+
+            @default_rank = options[:with_rank] == true ? 'rank' : options[:with_rank]&.to_s
+            @default_mode = options[:mode] || PostgreSQL.config.full_text_search.default_mode
+
+            @default_order =
+              case options[:order]
+              when :asc, true then :asc
+              when :desc then :desc
+              else false
+              end
+
+            @default_language = options[:language] if options[:language].is_a?(String) ||
+              options[:language].is_a?(Symbol)
+            @default_language ||= PostgreSQL.config.full_text_search.default_language.to_s
+          end
+
+          # What is the name of the scope to be added to the model
+          def scope_name
+            @scope_name ||= [
+              options[:prefix],
+              :full_text_search,
+              options[:suffix],
+            ].compact.join('_')
+          end
+
+          # Just check if the scope name is already defined
+          def conflicting?
+            return if options[:force] == true
+
+            if klass.dangerous_class_method?(scope_name)
+              raise Interrupt, scope_name.to_s
+            end
+          end
+
+          # Create the proper scope
+          def build
+            @klass_module = Module.new
+            add_scope_to_module
+            klass.extend klass_module
+          end
+
+          # Creates a class method as the scope that builds the full text search
+          def add_scope_to_module
+            klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{scope_name}(value#{scope_args})
+                attr = arel_table['#{attribute}']
+                fn = ::Torque::PostgreSQL::FN
+
+                lang = language.to_s if !language.is_a?(::Symbol)
+                lang ||= arel_table[language.to_s] if has_attribute?(language)
+                lang ||= public_send(language) if respond_to?(language)
+
+                function = {
+                  default: :to_tsquery,
+                  phrase: :phraseto_tsquery,
+                  plain: :plainto_tsquery,
+                  web: :websearch_to_tsquery,
+                }[mode.to_sym]
+
+                raise ::ArgumentError, <<~MSG.squish if lang.blank?
+                  Unable to determine language from \#{language.inspect}.
+                MSG
+
+                raise ::ArgumentError, <<~MSG.squish if function.nil?
+                  Invalid mode \#{mode.inspect} for full text search.
+                MSG
+
+                value = fn.bind(:value, value.to_s, attr.type_caster)
+                lang = fn.bind(:lang, lang, attr.type_caster) if lang.is_a?(::String)
+
+                query = fn.public_send(function, lang, value)
+                ranker = fn.ts_rank(attr, query) if rank || order
+
+                result = where(fn.infix(:"@@", attr, query))
+                result = result.order(ranker.public_send(order == :desc ? :desc : :asc)) if order
+                result.select_extra_values += [ranker.as(rank == true ? 'rank' : rank.to_s)] if rank
+                result
+              end
+            RUBY
+          end
+
+          # Returns the arguments to be used on the scope
+          def scope_args
+            args = +''
+            args << ", order: #{default_order.inspect}"
+            args << ", rank: #{default_rank.inspect}"
+            args << ", language: #{default_language.inspect}"
+            args << ", mode: :#{default_mode}"
+            args
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,13 +4,11 @@ module Torque
   module PostgreSQL
     module Attributes
       module Builder
-        # TODO: Allow documenting by building the methods outside and importing
-        # only the raw string
         class Period
           DIRECT_ACCESS_REGEX = /_?%s_?/
           SUPPORTED_TYPES = %i[daterange tsrange tstzrange].freeze
           CURRENT_GETTERS = {
-            daterange: 'Date.today',
+            daterange: 'Date.current',
             tsrange:   'Time.zone.now',
             tstzrange: 'Time.zone.now',
           }.freeze
@@ -21,6 +19,8 @@ module Torque
             tstzrange: :timestamp,
           }.freeze
 
+          FN = '::Torque::PostgreSQL::FN'
+
           attr_accessor :klass, :attribute, :options, :type, :default, :current_getter,
             :type_caster, :threshold, :dynamic_threshold, :klass_module, :instance_module
 
@@ -208,11 +208,11 @@ module Torque
             end
 
             def arel_default_sql
-              @arel_default_sql ||= arel_sql_quote(@default.inspect)
+              @arel_default_sql ||= arel_sql_bind(@default.inspect)
             end
 
-            def arel_sql_quote(value)
-              "::Arel.sql(connection.quote(#{value}))"
+            def arel_sql_bind(value)
+              "#{FN}.bind_with(#{arel_attribute}, #{value})"
             end
 
             # Check how to provide the threshold value
@@ -223,12 +223,12 @@ module Torque
                   "arel_table['#{threshold}']"
                 when ActiveSupport::Duration
                   value = "'#{threshold.to_i} seconds'"
-                  "::Arel.sql(\"#{value}\").cast(:interval)"
+                  "::Arel.sql(\"#{value}\").pg_cast(:interval)"
                 when Numeric
                   value = threshold.to_i.to_s
                   value << type_caster.eql?(:date) ? ' days' : ' seconds'
                   value = "'#{value}'"
-                  "::Arel.sql(\"#{value}\").cast(:interval)"
+                  "::Arel.sql(\"#{value}\").pg_cast(:interval)"
                 end
               end
             end
@@ -248,7 +248,7 @@ module Torque
               return arel_start_at unless threshold.present?
               @arel_real_start_at ||= begin
                 result = +"(#{arel_start_at} - #{arel_threshold_value})"
-                result << '.cast(:date)' if  type.eql?(:daterange)
+                result << '.pg_cast(:date)' if type.eql?(:daterange)
                 result
               end
             end
@@ -258,7 +258,7 @@ module Torque
               return arel_finish_at unless threshold.present?
               @arel_real_finish_at ||= begin
                 result = +"(#{arel_finish_at} + #{arel_threshold_value})"
-                result << '.cast(:date)' if  type.eql?(:daterange)
+                result << '.pg_cast(:date)' if type.eql?(:daterange)
                 result
               end
             end
@@ -278,9 +278,9 @@ module Torque
 
             # Create an arel named function
             def arel_named_function(name, *args)
-              result = +"::Arel::Nodes::NamedFunction.new(#{name.to_s.inspect}"
-              result << ', [' << args.join(', ') << ']' if args.present?
-              result << ')'
+              result = +"#{FN}.#{name}"
+              result << '(' << args.join(', ') << ')' if args.present?
+              result
             end
 
             # Create an arel version of +nullif+ function
@@ -302,24 +302,24 @@ module Torque
             def arel_daterange(real = false)
               arel_named_function(
                 'daterange',
-                (real ? arel_real_start_at : arel_start_at) + '.cast(:date)',
-                (real ? arel_real_finish_at : arel_finish_at) + '.cast(:date)',
+                (real ? arel_real_start_at : arel_start_at) + '.pg_cast(:date)',
+                (real ? arel_real_finish_at : arel_finish_at) + '.pg_cast(:date)',
                 '::Arel.sql("\'[]\'")',
               )
             end
 
             def arel_check_condition(type)
               checker = arel_nullif(arel_real_attribute, arel_empty_value)
-              checker << ".#{type}(value.cast(#{type_caster.inspect}))"
+              checker << ".#{type}(value.pg_cast(#{type_caster.inspect}))"
               arel_coalesce(checker, arel_default_sql)
             end
 
             def arel_formatting_value(condition = nil, value = 'value', cast: nil)
               [
                 "#{value} = arel_table[#{value}] if #{value}.is_a?(Symbol)",
-                "unless #{value}.respond_to?(:cast)",
-                "  #{value} = ::Arel.sql(connection.quote(#{value}))",
-                ("  #{value} = #{value}.cast(#{cast.inspect})" if cast),
+                "unless #{value}.respond_to?(:pg_cast)",
+                "  #{value} = #{FN}.bind_with(#{arel_attribute}, #{value})",
+                ("  #{value} = #{value}.pg_cast(#{cast.inspect})" if cast),
                 'end',
                 condition,
               ].compact.join("\n")
@@ -347,14 +347,14 @@ module Torque
 
             def klass_current
               [
-                "value = #{arel_sql_quote(current_getter)}",
+                "value = #{arel_sql_bind(current_getter)}",
                 "where(#{arel_check_condition(:contains)})",
               ].join("\n")
             end
 
             def klass_not_current
               [
-                "value = #{arel_sql_quote(current_getter)}",
+                "value = #{arel_sql_bind(current_getter)}",
                 "where.not(#{arel_check_condition(:contains)})",
               ].join("\n")
             end

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

@@ -2,6 +2,7 @@
 
 require_relative 'builder/enum'
 require_relative 'builder/period'
+require_relative 'builder/full_text_search'
 
 module Torque
   module PostgreSQL
@@ -12,20 +13,57 @@ module Torque
             return unless table_exists?
 
             args.each do |attribute|
-              begin
-                # Generate methods on self class
-                builder = builder_klass.new(self, attribute, extra.merge(options))
-                builder.conflicting?
-                builder.build
-
-                # Additional settings for the builder
-                instance_exec(builder, &block) if block.present?
-              rescue Interrupt
-                # Not able to build the attribute, maybe pending migrations
-              end
+              # Generate methods on self class
+              builder = builder_klass.new(self, attribute, extra.merge(options))
+              builder.conflicting?
+              builder.build
+
+              # Additional settings for the builder
+              instance_exec(builder, &block) if block.present?
+            rescue Interrupt
+              # Not able to build the attribute, maybe pending migrations
             end
           end
         end
+
+        def self.search_vector_options(columns:, language: nil, stored: true, **options)
+          weights = to_search_weights(columns)
+          operation = to_search_vector_operation(language, weights).to_sql
+
+          options[:index] = {
+            using: PostgreSQL.config.full_text_search.default_index_type,
+          } if options[:index] == true
+
+          options.merge(type: :tsvector, as: operation, stored: stored)
+        end
+
+        def self.to_search_weights(columns)
+          if !columns.is_a?(Hash)
+            extras = columns.size > 3 ? columns.size - 3 : 0
+            weights = %w[A B C] + (['D'] * extras)
+            columns = Array.wrap(columns).zip(weights).to_h
+          end
+
+          columns.transform_keys(&:to_s)
+        end
+
+        def self.to_search_vector_operation(language, weights)
+          language ||= PostgreSQL.config.full_text_search.default_language
+          language = ::Arel.sql(language.is_a?(Symbol) ? language.to_s : "'#{language}'")
+          simple = weights.size == 1
+
+          empty_string = ::Arel.sql("''")
+          operations = weights.map do |column, weight|
+            column = ::Arel.sql(column.to_s)
+            weight = ::Arel.sql("'#{weight}'")
+
+            op = FN.to_tsvector(language, FN.coalesce(column, empty_string))
+            op = FN.setweight(op, weight) unless simple
+            op
+          end
+
+          FN.concat(*operations)
+        end
       end
     end
   end

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

@@ -18,7 +18,7 @@ module Torque
           # Find or create the class that will handle the value
           def lookup(name)
             const     = name.to_s.camelize
-            namespace = Torque::PostgreSQL.config.enum.namespace
+            namespace = PostgreSQL.config.enum.namespace
 
             return namespace.const_get(const) if namespace.const_defined?(const)
             namespace.const_set(const, Class.new(Enum))
@@ -27,7 +27,7 @@ module Torque
           # Provide a method on the given class to setup which enums will be
           # manually initialized
           def include_on(klass, method_name = nil)
-            method_name ||= Torque::PostgreSQL.config.enum.base_method
+            method_name ||= PostgreSQL.config.enum.base_method
             Builder.include_on(klass, method_name, Builder::Enum) do |builder|
               defined_enums[builder.attribute.to_s] = builder.subtype.klass
             end
@@ -46,7 +46,7 @@ module Torque
             end
           end
 
-          # List of valus as symbols
+          # List of values as symbols
           def keys
             values.map(&:to_sym)
           end
@@ -86,7 +86,7 @@ module Torque
             self.values.include?(value.to_s)
           end
 
-          # Build an active record scope for a given atribute agains a value
+          # Build an active record scope for a given attribute against a value
           def scope(attribute, value)
             attribute.eq(value)
           end
@@ -183,7 +183,7 @@ module Torque
               list_from = :i18n_scopes
             end
 
-            Torque::PostgreSQL.config.enum.send(list_from).map do |key|
+            PostgreSQL.config.enum.send(list_from).map do |key|
               (key % values).to_sym
             end
           end
@@ -209,7 +209,7 @@ module Torque
             end
           end
 
-          # Throw an exception for invalid valus
+          # Throw an exception for invalid values
           def raise_invalid(value)
             if value.is_a?(Numeric)
               raise EnumError, "#{value.inspect} is out of bounds of #{self.class.name}"
@@ -218,7 +218,7 @@ module Torque
             end
           end
 
-          # Throw an exception for comparasion between different enums
+          # Throw an exception for comparison between different enums
           def raise_comparison(other)
             raise EnumError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end

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

@@ -18,7 +18,7 @@ module Torque
           # Find or create the class that will handle the value
           def lookup(name, enum_klass)
             const     = name.to_s.camelize + 'Set'
-            namespace = Torque::PostgreSQL.config.enum.namespace
+            namespace = PostgreSQL.config.enum.namespace
 
             return namespace.const_get(const) if namespace.const_defined?(const)
 
@@ -30,7 +30,7 @@ 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)
-            method_name ||= Torque::PostgreSQL.config.enum.set_method
+            method_name ||= PostgreSQL.config.enum.set_method
             Builder.include_on(klass, method_name, Builder::Enum, set_features: true) do |builder|
               defined_enums[builder.attribute.to_s] = builder.subtype
             end
@@ -76,14 +76,14 @@ module Torque
             end.reduce(:+)
           end
 
-          # Build an active record scope for a given atribute agains a value
+          # Build an active record scope for a given attribute against a value
           def scope(attribute, value)
-            attribute.contains(::Arel.array(value, cast: enum_source.type_name))
+            attribute.contains(FN.bind_with(attribute, value).pg_cast(type_name))
           end
 
           private
 
-            # Allows checking value existance
+            # Allows checking value existence
             def respond_to_missing?(method_name, include_private = false)
               valid?(method_name) || super
             end
@@ -226,7 +226,7 @@ module Torque
             end
           end
 
-          # Throw an exception for invalid valus
+          # Throw an exception for invalid values
           def raise_invalid(value)
             if value.is_a?(Numeric)
               raise EnumSetError, "#{value.inspect} is out of bounds of #{self.class.name}"
@@ -235,7 +235,7 @@ module Torque
             end
           end
 
-          # Throw an exception for comparasion between different enums
+          # Throw an exception for comparison between different enums
           def raise_comparison(other)
             raise EnumSetError, "Comparison of #{self.class.name} with #{self.inspect} failed"
           end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      # For now, full text search doesn't have it's own class
+      module FullTextSearch
+        class << self
+          # Provide a method on the given class to setup which full text search
+          # columns will be manually initialized
+          def include_on(klass, method_name = nil)
+            method_name ||= PostgreSQL.config.full_text_search.base_method
+            Builder.include_on(klass, method_name, Builder::FullTextSearch)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,13 +3,13 @@
 module Torque
   module PostgreSQL
     module Attributes
-      # For naw, period doesn't have it's own class
+      # For now, 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 = nil)
-            method_name ||= Torque::PostgreSQL.config.period.base_method
+            method_name ||= PostgreSQL.config.period.base_method
             Builder.include_on(klass, method_name, Builder::Period)
           end
         end