sequel 5.19.0 → 5.20.0

data/lib/sequel/model/plugins.rb

@@ -51,5 +51,109 @@ module Sequel
         r
       end
     end
+
+    method_num = 0
+    method_num_mutex = Mutex.new
+    # Return a unique method name symbol for the given suffix.
+    SEQUEL_METHOD_NAME = lambda do |suffix|
+      :"_sequel_#{suffix}_#{method_num_mutex.synchronize{method_num += 1}}"
+    end
+
+    # Define a private instance method using the block with the provided name and
+    # expected arity.  If the name is given as a Symbol, it is used directly.
+    # If the name is given as a String, a unique name will be generated using
+    # that string.  The expected_arity should be either 0 (no arguments) or
+    # 1 (single argument).
+    #
+    # If a block with an arity that does not match the expected arity is used,
+    # a deprecation warning will be issued. The method defined should still
+    # work, though it will be slower than a method with the expected arity.
+    #
+    # Sequel only checks arity for regular blocks, not lambdas.  Lambdas were
+    # already strict in regards to arity, so there is no need to try to fix
+    # arity to keep backwards compatibility for lambdas.
+    #
+    # Blocks with required keyword arguments are not supported by this method.
+    def self.def_sequel_method(model, meth, expected_arity, &block)
+      if meth.is_a?(String)
+        meth = SEQUEL_METHOD_NAME.call(meth)
+      end
+      call_meth = meth
+
+      unless block.lambda?
+        required_args, optional_args, rest, keyword = _define_sequel_method_arg_numbers(block)
+
+        if keyword == :required
+          raise Error, "cannot use block with required keyword arguments when calling define_sequel_method with expected arity #{expected_arity}"
+        end
+
+        case expected_arity
+        when 0
+          unless required_args == 0
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 0, but arguments required for #{block.inspect}. Support for this will be removed in Sequel 6.")
+            b = block
+            block = lambda{instance_exec(&b)} # Fallback
+          end
+        when 1
+          if required_args == 0 && optional_args == 0 && !rest
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 1, but no arguments accepted for #{block.inspect}.  Support for this will be removed in Sequel 6.")
+            temp_method = SEQUEL_METHOD_NAME.call("temp")
+            model.class_eval("def #{temp_method}(_) #{meth =~ /\A\w+\z/ ? "#{meth}_arity" : "send(:\"#{meth}_arity\")"} end", __FILE__, __LINE__)
+            model.send(:alias_method, meth, temp_method)
+            model.send(:undef_method, temp_method)
+            model.send(:private, meth)
+            meth = :"#{meth}_arity"
+          elsif required_args > 1
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 1, but more arguments required for #{block.inspect}.  Support for this will be removed in Sequel 6.")
+            b = block
+            block = lambda{|r| instance_exec(r, &b)} # Fallback
+          end
+        else
+          raise Error, "unexpected arity passed to define_sequel_method: #{expected_arity.inspect}"
+        end
+      end
+
+      model.send(:define_method, meth, &block)
+      model.send(:private, meth)
+      call_meth
+    end
+
+    # Return the number of required argument, optional arguments,
+    # whether the callable accepts any additional arguments,
+    # and whether the callable accepts keyword arguments (true, false
+    # or :required).
+    def self._define_sequel_method_arg_numbers(callable)
+      optional_args = 0
+      rest = false
+      keyword = false
+      callable.parameters.map(&:first).each do |arg_type, _|
+        case arg_type
+        when :opt
+          optional_args += 1
+        when :rest
+          rest = true
+        when :keyreq
+          keyword = :required
+        when :key, :keyrest
+          keyword ||= true
+        end
+      end
+      arity = callable.arity
+      if arity < 0
+        arity = arity.abs - 1
+      end
+      required_args = arity
+      arity -= 1 if keyword == :required
+
+      if callable.is_a?(Proc) && !callable.lambda?
+        optional_args -= arity
+      end
+
+      [required_args, optional_args, rest, keyword]
+    end
+    private_class_method :_define_sequel_method_arg_numbers
   end
 end

data/lib/sequel/plugins/association_dependencies.rb

@@ -60,9 +60,9 @@ module Sequel
             association_dependencies[:"#{time}_#{action}"] << if action == :nullify
               case type
               when :one_to_many , :many_to_many
-                proc{public_send(r[:remove_all_method])}
+                [r[:remove_all_method]]
               when :one_to_one
-                proc{public_send(r[:setter_method], nil)}
+                [r[:setter_method], nil]
               else
                 raise(Error, "Can't nullify many_to_one associated objects: association: #{association}")
               end
@@ -97,7 +97,7 @@ module Sequel
         def before_destroy
           model.association_dependencies[:before_delete].each{|m| public_send(m).delete}
           model.association_dependencies[:before_destroy].each{|m| public_send(m).destroy}
-          model.association_dependencies[:before_nullify].each{|p| instance_exec(&p)}
+          model.association_dependencies[:before_nullify].each{|args| public_send(*args)}
           super
         end
       end

data/lib/sequel/plugins/association_pks.rb

@@ -60,8 +60,15 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
+          opts[:pks_getter_method] = :"#{singularize(opts[:name])}_pks_getter"
+          association_module_def(opts[:pks_getter_method], &opts[:pks_getter])
           association_module_def(:"#{singularize(opts[:name])}_pks", opts){_association_pks_getter(opts)}
-          association_module_def(:"#{singularize(opts[:name])}_pks=", opts){|pks| _association_pks_setter(opts, pks)} if opts[:pks_setter]
+
+          if opts[:pks_setter]
+            opts[:pks_setter_method] = :"#{singularize(opts[:name])}_pks_setter"
+            association_module_def(opts[:pks_setter_method], &opts[:pks_setter])
+            association_module_def(:"#{singularize(opts[:name])}_pks=", opts){|pks| _association_pks_setter(opts, pks)}
+          end
         end
 
         # Add a getter that checks the join table for matching records and
@@ -181,7 +188,8 @@ module Sequel
         def after_save
           if assoc_pks = @_association_pks
             assoc_pks.each do |name, pks|
-              instance_exec(pks, &model.association_reflection(name)[:pks_setter])
+             # pks_setter_method is private
+              send(model.association_reflection(name)[:pks_setter_method], pks)
             end
             @_association_pks = nil
           end
@@ -206,7 +214,8 @@ module Sequel
           elsif delay && @_association_pks && (objs = @_association_pks[opts[:name]])
             objs
           else
-            instance_exec(&opts[:pks_getter])
+           # pks_getter_method is private
+            send(opts[:pks_getter_method])
           end
         end
 
@@ -231,7 +240,8 @@ module Sequel
             modified!
             (@_association_pks ||= {})[opts[:name]] = pks
           else
-            instance_exec(pks, &opts[:pks_setter])
+            # pks_setter_method is private
+            send(opts[:pks_setter_method], pks)
           end
         end
 

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -326,6 +326,7 @@ module Sequel
             cti_tables.reverse_each do |ct|
               db.schema(ct).each{|sk,v| db_schema[sk] = v}
             end
+            setup_auto_validations if respond_to?(:setup_auto_validations, true)
           end
         end
 

data/lib/sequel/plugins/composition.rb

@@ -32,9 +32,10 @@ module Sequel
     #
     # The :mapping option is just a shortcut that works in particular
     # cases.  To handle any case, you can define a custom :composer
-    # and :decomposer procs.  The :composer proc will be instance_execed
-    # the first time the getter is called, and the :decomposer proc
-    # will be instance_execed before saving.  The above example could
+    # and :decomposer procs.  The :composer and :decomposer procs will
+    # be used to define instance methods.  The :composer will be called
+    # the first time the getter is called, and the :decomposer 
+    # will be called before saving.  The above example could
     # also be implemented as:
     #
     #   Album.composition :date,
@@ -74,9 +75,9 @@ module Sequel
         #
         # Options:
         # :class :: if using the :mapping option, the class to use, as a Class, String or Symbol.
-        # :composer :: A proc that is instance_execed when the composition getter method is called
+        # :composer :: A proc used to define the method that the composition getter method will call 
         #              to create the composition.
-        # :decomposer :: A proc that is instance_execed before saving the model object,
+        # :decomposer :: A proc used to define the method called before saving the model object,
         #                if the composition object exists, which sets the columns in the model object
         #                based on the value of the composition object.
         # :mapping :: An array where each element is either a symbol or an array of two symbols.
@@ -129,15 +130,17 @@ module Sequel
         
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts=OPTS)
-          composer = opts[:composer]
+          composer_meth = opts[:composer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_composer", 0, &opts[:composer])
+          opts[:decomposer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_decomposer", 0, &opts[:decomposer])
           @composition_module.class_eval do
             define_method(name) do 
               if compositions.has_key?(name)
                 compositions[name]
               elsif frozen?
-                instance_exec(&composer)
+                # composer_meth is private
+                send(composer_meth)
               else
-                compositions[name] = instance_exec(&composer)
+                compositions[name] = send(composer_meth)
               end
             end
             define_method("#{name}=") do |v|
@@ -171,7 +174,8 @@ module Sequel
         # For each composition, set the columns in the model class based
         # on the composition object.
         def before_validation
-          @compositions.keys.each{|n| instance_exec(&model.compositions[n][:decomposer])} if @compositions
+          # decomposer_method is private
+          @compositions.keys.each{|n| send(model.compositions[n][:decomposer_method])} if @compositions
           super
         end
         

data/lib/sequel/plugins/finder.rb

@@ -35,8 +35,8 @@ module Sequel
     module Finder
       FINDER_TYPES = [:first, :all, :each, :get].freeze
 
-      def self.apply(mod)
-        mod.instance_exec do
+      def self.apply(model)
+        model.instance_exec do
           @finders ||= {}
           @finder_loaders ||= {}
         end

data/lib/sequel/plugins/hook_class_methods.rb

@@ -59,7 +59,14 @@ module Sequel
     
         # Yield every block related to the given hook.
         def hook_blocks(hook)
-          @hooks[hook].each{|k,v| yield v}
+          # SEQUEL6: Remove
+          Sequel::Deprecation.deprecate("The hook_blocks class method in the hook_class_methods plugin is deprecated and will be removed in Sequel 6.")
+          @hooks[hook].each{|_,v,_| yield v}
+        end
+
+        # Yield every method related to the given hook.
+        def hook_methods_for(hook)
+          @hooks[hook].each{|_,_,m| yield m}
         end
 
         Plugins.inherited_instance_variables(self, :@hooks=>:hash_dup)
@@ -75,23 +82,28 @@ module Sequel
             # Allow calling private hook methods
             block = proc {send(tag)}
           end
+
           h = @hooks[hook]
+
           if tag && (old = h.find{|x| x[0] == tag})
             old[1] = block
+            Plugins.def_sequel_method(self, old[2], 0, &block)
           else
+            meth = Plugins.def_sequel_method(self, "validation_class_methods_#{hook}", 0, &block)
             if hook.to_s =~ /^before/
-              h.unshift([tag,block])
+              h.unshift([tag, block, meth])
             else
-              h << [tag, block]
+              h << [tag, block, meth]
             end
           end
         end
       end
 
       module InstanceMethods
-        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| instance_exec(&b)}; super end", __FILE__, __LINE__)}
+        # hook methods are private
+        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_methods_for(:#{h}){|m| send(m)}; super end", __FILE__, __LINE__)}
 
-        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_exec(&b)}; end", __FILE__, __LINE__)}
+        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_methods_for(:#{h}){|m| send(m)}; end", __FILE__, __LINE__)}
       end
     end
   end

data/lib/sequel/plugins/inverted_subsets.rb

@@ -29,8 +29,8 @@ module Sequel
     #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
     #
     module InvertedSubsets
-      def self.apply(mod, &block)
-        mod.instance_exec do
+      def self.apply(model, &block)
+        model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
             include DatasetModuleMethods
             if block

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -22,8 +22,9 @@ module Sequel
     # This plugin is not intended as a replacement for other validations,
     # it is intended as a last resort.  The purpose of validations is to provide nice
     # error messages for the user, and the error messages generated by this plugin are
-    # fairly generic.  The error messages can be customized using the :messages plugin
-    # option, but there is only a single message used per constraint type.
+    # fairly generic by default.  The error messages can be customized per constraint type
+    # using the :messages plugin option, and individually per constraint using
+    # +pg_auto_constraint_validation_override+ (see below).
     #
     # This plugin only works on the postgres adapter when using the pg 0.16+ driver,
     # PostgreSQL 9.3+ server, and PostgreSQL 9.3+ client library (libpq). In other cases
@@ -37,6 +38,13 @@ module Sequel
     #   rescue Sequel::ValidationFailed
     #     album.errors.on(:artist_id) # ['is invalid']
     #   end
+    #
+    # While the database usually provides enough information to correctly associated
+    # constraint violations with model columns, there are cases where it does not.
+    # In those cases, you can override the handling of specific constraint violations
+    # to be associated to particular column(s), and use a specific error message:
+    #
+    #   Album.pg_auto_constraint_validation_override(:constraint_name, [:column1], "validation error message")
     # 
     # Usage:
     #
@@ -80,6 +88,16 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil)
         Plugins.after_set_dataset(self, :setup_pg_auto_constraint_validations)
 
+        # Override the constraint validation columns and message for a given constraint
+        def pg_auto_constraint_validation_override(constraint, columns, message)
+          pgacv = Hash[@pg_auto_constraint_validations]
+          overrides = pgacv[:overrides] = Hash[pgacv[:overrides]]
+          overrides[constraint] = [Array(columns), message].freeze
+          overrides.freeze
+          @pg_auto_constraint_validations = pgacv.freeze
+          nil
+        end
+
         private
 
         # Get the list of constraints, unique indexes, foreign keys in the current
@@ -110,7 +128,7 @@ module Sequel
           referenced_by = {}
 
           db.check_constraints(table_name).each do |k, v|
-            checks[k] = v[:columns].dup.freeze
+            checks[k] = v[:columns].dup.freeze unless v[:columns].empty?
           end
           db.indexes(table_name, :include_partial=>true).each do |k, v|
             if v[:unique]
@@ -134,7 +152,8 @@ module Sequel
             :check=>checks,
             :unique=>indexes,
             :foreign_key=>foreign_keys,
-            :referenced_by=>referenced_by
+            :referenced_by=>referenced_by,
+            :overrides=>OPTS
           }.freeze).each_value(&:freeze)
         end
       end
@@ -158,40 +177,50 @@ module Sequel
             m = ds.method(:output_identifier)
             schema = info[:schema]
             table = info[:table]
+
             if constraint = info[:constraint]
               constraint = m.call(constraint)
+
+              columns, message = cv_info[:overrides][constraint]
+              if columns
+                override = true
+                add_pg_constraint_validation_error(columns, message)
+              end
             end
+
             messages = model.pg_auto_constraint_validations_messages
 
-            case e
-            when Sequel::NotNullConstraintViolation
-              if column = info[:column]
-                add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
-              end
-            when Sequel::CheckConstraintViolation
-              if columns = cv_info[:check][constraint]
-                add_pg_constraint_validation_error(columns, messages[:check])
-              end
-            when Sequel::UniqueConstraintViolation
-              if columns = cv_info[:unique][constraint]
-                add_pg_constraint_validation_error(columns, messages[:unique])
-              end
-            when Sequel::ForeignKeyConstraintViolation
-              message_primary = info[:message_primary]
-              if message_primary.start_with?('update')
-                # This constraint violation is different from the others, because the constraint
-                # referenced is a constraint for a different table, not for this table.  This
-                # happens when another table references the current table, and the referenced
-                # column in the current update is modified such that referential integrity
-                # would be broken.  Use the reverse foreign key information to figure out
-                # which column is affected in that case.
-                skip_schema_table_check = true
-                if columns = cv_info[:referenced_by][[m.call(schema), m.call(table), constraint]]
-                  add_pg_constraint_validation_error(columns, messages[:referenced_by])
+            unless override
+              case e
+              when Sequel::NotNullConstraintViolation
+                if column = info[:column]
+                  add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
+                end
+              when Sequel::CheckConstraintViolation
+                if columns = cv_info[:check][constraint]
+                  add_pg_constraint_validation_error(columns, messages[:check])
+                end
+              when Sequel::UniqueConstraintViolation
+                if columns = cv_info[:unique][constraint]
+                  add_pg_constraint_validation_error(columns, messages[:unique])
                 end
-              elsif message_primary.start_with?('insert')
-                if columns = cv_info[:foreign_key][constraint]
-                  add_pg_constraint_validation_error(columns, messages[:foreign_key])
+              when Sequel::ForeignKeyConstraintViolation
+                message_primary = info[:message_primary]
+                if message_primary.start_with?('update')
+                  # This constraint violation is different from the others, because the constraint
+                  # referenced is a constraint for a different table, not for this table.  This
+                  # happens when another table references the current table, and the referenced
+                  # column in the current update is modified such that referential integrity
+                  # would be broken.  Use the reverse foreign key information to figure out
+                  # which column is affected in that case.
+                  skip_schema_table_check = true
+                  if columns = cv_info[:referenced_by][[m.call(schema), m.call(table), constraint]]
+                    add_pg_constraint_validation_error(columns, messages[:referenced_by])
+                  end
+                elsif message_primary.start_with?('insert')
+                  if columns = cv_info[:foreign_key][constraint]
+                    add_pg_constraint_validation_error(columns, messages[:foreign_key])
+                  end
                 end
               end
             end