sequel 4.44.0 → 4.45.0

data/lib/sequel/plugins/association_pks.rb

@@ -29,6 +29,12 @@ module Sequel
     # objects, and the setting will not be persisted until after the object has
     # been saved.
     #
+    # SEQUEL5: Starting in Sequel 5, the :delay_pks association option will default
+    # to :delay_pks=>:always.  If you would like to use the Sequel 4 behavior of
+    # having the setter make modifications immediately, explicitly use the
+    # :delay_pks=>false option.  Additionally, Sequel 5 will not support the current
+    # :delay_pks=>true behavior, treating it as :delay_pks=>:always.
+    #
     # By default, if you pass a nil value to the setter, an exception will be raised.
     # You can change this behavior by using the :association_pks_nil association option.
     # If set to :ignore, the setter will take no action if nil is given.
@@ -201,11 +207,17 @@ module Sequel
 
           pks = convert_pk_array(opts, pks)
 
-          delay = opts[:delay_pks]
+          delay = opts.fetch(:delay_pks) do
+            Sequel::Deprecation.deprecate("association_pks will default to assuming the :delay_pks=>:always association option starting in Sequel 5.  Explicitly set :delay_pks=>false option for the association if you want changes to take effect immediately instead of being delayed until the object is saved (association: #{opts.inspect}).")
+            false
+          end
           if (new? && delay) || (delay == :always)
             modified!
             (@_association_pks ||= {})[opts[:name]] = pks
           else
+            if !new? && delay && delay != :always
+              Sequel::Deprecation.deprecate("association_pks with the :delay_pks=>true association option will also delay setting of associated values for existing objects in Sequel 5 (currently it just delays setting of associated values for new objects).  Please change to using :delay_pks=>:always to avoid this message.  Sequel 5 will not support the existing :delay_pks=>true behavior for only delaying for new objects and not for existing objects.")
+            end
             instance_exec(pks, &opts[:pks_setter])
           end
         end

data/lib/sequel/plugins/association_proxies.rb

@@ -99,7 +99,14 @@ module Sequel
         # Changes the association method to return a proxy instead of the associated objects
         # directly.
         def def_association_method(opts)
-          opts.returns_array? ? association_module_def(opts.association_method, opts){|*r, &block| AssociationProxy.new(self, opts, r[0], &block)} : super
+          if opts.returns_array?
+            association_module_def(opts.association_method, opts) do |*dynamic_opts, &block|
+              Sequel::Deprecation.deprecate("Passing multiple arguments to ##{opts.association_method}", "Additional arguments are currently ignored.") if dynamic_opts.length > 1
+              AssociationProxy.new(self, opts, dynamic_opts.length == 0 ? OPTS : dynamic_opts[0], &block)
+            end
+          else
+            super
+          end
         end
       end
     end

data/lib/sequel/plugins/before_after_save.rb

@@ -21,6 +21,7 @@ module Sequel
     #   Album.plugin :before_after_save
     module BeforeAfterSave
       module InstanceMethods
+        # SEQUEL5: Make module empty as it will be the default behavior
         private
 
         # Refresh and reset modified flag right after INSERT query.

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -100,7 +100,7 @@ module Sequel
     # by explicitly qualifying it:
     #
     #   a = Executive.where(:id=>1).first # database error
-    #   a = Executive.where(:executives__id=>1).first # no error
+    #   a = Executive.where{{executives[:id]=>1}}.first # no error
     #
     # = Usage
     #
@@ -287,12 +287,16 @@ module Sequel
             if cti_tables.length == 1
               ds = ds.select(*self.columns.map{|cc| Sequel.qualify(table_name, Sequel.identifier(cc))})
             end
-            sel_app = (columns - [pk]).map{|cc| Sequel.qualify(table, Sequel.identifier(cc))}
+            cols = columns - [pk]
+            unless (cols & ds.columns).empty?
+              Sequel::Deprecation.deprecate('Using class_table_inheritance with duplicate column names in subclass tables (other than the primary key column)', 'Make sure all tables used have unique column names, or implement support for handling duplicate column names in the class_table_inheritance plugin')
+            end
+            sel_app = cols.map{|cc| Sequel.qualify(table, Sequel.identifier(cc))}
             @sti_dataset = ds.join(table, pk=>pk).select_append(*sel_app)
             set_dataset(@sti_dataset)
             set_columns(self.columns)
             @dataset = @dataset.with_row_proc(lambda{|r| subclass.sti_load(r)})
-            (columns - [pk]).each{|a| define_lazy_attribute_getter(a, :dataset=>dataset, :table=>table)}
+            cols.each{|a| define_lazy_attribute_getter(a, :dataset=>dataset, :table=>table)}
 
             @cti_models += [self]
             @cti_tables += [table]

data/lib/sequel/plugins/columns_updated.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The columns_updated plugin stores the columns hash used in the
+    # UPDATE query when saving the instance, and makes it available
+    # in the after_update and after_save hooks via the +columns_updated+
+    # accessor.  The data is cleared before returning from +save+.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses store the columns hash used for updating
+    #   Sequel::Model.plugin :columns_updated
+    #
+    #   # Make the Album class store the columns hash used for updating
+    #   Album.plugin :columns_updated
+    module ColumnsUpdated
+      module InstanceMethods
+        private
+
+        # The hash used for updating records.  This should only be called
+        # in the after_update and after_save hooks.
+        attr_reader :columns_updated
+
+        # Store the hash used for updating the record, so it can be accessed
+        # in the after_hooks.
+        def _update_columns(columns_updated)
+          @columns_updated = columns_updated
+          super
+        end
+
+        # Unset the updated columns hash before returning from save.
+        def _save(opts)
+          super
+        ensure
+          @columns_updated = nil
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/composition.rb

@@ -69,9 +69,14 @@ module Sequel
         # hash values.
         attr_reader :compositions
         
-        # A module included in the class holding the composition
-        # getter and setter methods.
-        attr_reader :composition_module
+        def composition_module
+          Sequel::Deprecation.deprecate('Sequel::Model.composition_module', 'There is no replacement')
+          @composition_module
+        end
+        def composition_module=(v)
+          Sequel::Deprecation.deprecate('Sequel::Model.composition_module=', 'There is no replacement')
+          @composition_module = v
+        end
         
         # Define a composition for this model, with name being the name of the composition.
         # You must provide either a :mapping option or both the :composer and :decomposer options. 
@@ -134,7 +139,7 @@ module Sequel
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts=OPTS)
           composer = opts[:composer]
-          composition_module.class_eval do
+          @composition_module.class_eval do
             define_method(name) do 
               if compositions.has_key?(name)
                 compositions[name]
@@ -154,7 +159,7 @@ module Sequel
         # Freeze composition information when freezing model class.
         def freeze
           compositions.freeze.each_value(&:freeze)
-          composition_module.freeze
+          @composition_module.freeze
 
           super
         end

data/lib/sequel/plugins/error_splitter.rb

@@ -35,7 +35,7 @@ module Sequel
         # If the model instance is not valid, go through all of the errors entries.  For
         # any that apply to multiple columns, remove them and add separate error entries,
         # one per column.
-        def _valid?(*)
+        def _valid?(opts)
           v = super
           unless v
             errors.keys.select{|k| k.is_a?(Array)}.each do |ks|

data/lib/sequel/plugins/hook_class_methods.rb

@@ -34,6 +34,14 @@ module Sequel
     #   # Allow the use of hook class methods in the Album class
     #   Album.plugin :hook_class_methods
     module HookClassMethods
+      # SEQUEL5: Remove
+      DEPRECATION_REPLACEMENTS = {
+        :after_commit=>"Use after_save{db.after_commit{}} instead",
+        :after_destroy_commit=>"Use after_destroy{db.after_commit{}} instead",
+        :after_destroy_rollback=>"Use before_destroy{db.after_rollback{}} instead",
+        :after_rollback=>"Use before_save{db.after_rollback{}} instead"
+      }.freeze
+
       # Set up the hooks instance variable in the model.
       def self.apply(model)
         hooks = model.instance_variable_set(:@hooks, {})
@@ -41,7 +49,14 @@ module Sequel
       end
 
       module ClassMethods
-        Model::HOOKS.each{|h| class_eval("def #{h}(method = nil, &block); add_hook(:#{h}, method, &block) end", __FILE__, __LINE__)}
+        Model::HOOKS.each do |h|
+          class_eval(<<-END, __FILE__, __LINE__ + 1)
+            def #{h}(method = nil, &block)
+              #{"Sequel::Deprecation.deprecate('Sequel::Model.#{h} in the hook_class_methods plugin', #{DEPRECATION_REPLACEMENTS[h].inspect})" if DEPRECATION_REPLACEMENTS[h]}
+              add_hook(:#{h}, method, &block)
+            end
+          END
+        end
 
         # This adds a new hook type. It will define both a class
         # method that you can use to add hooks, as well as an instance method
@@ -75,11 +90,12 @@ module Sequel
         # Do not call this method with untrusted input, as that can result in
         # arbitrary code execution.
         def add_hook_type(*hooks)
+          Sequel::Deprecation.deprecate("Sequel::Model.add_hook_type", "You should add your own hook types manually")
           Model::HOOKS.concat(hooks)
           hooks.each do |hook|
             @hooks[hook] = []
             instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end", __FILE__, __LINE__)
-            class_eval("def #{hook}; model.hook_blocks(:#{hook}){|b| return false if instance_eval(&b) == false}; end", __FILE__, __LINE__)
+            class_eval("def #{hook}; model.hook_blocks(:#{hook}){|b| return false if instance_eval(&b) == false} end", __FILE__, __LINE__)
           end
         end
 
@@ -125,7 +141,19 @@ module Sequel
       end
 
       module InstanceMethods
-        (Model::BEFORE_HOOKS - [:before_save, :before_destroy]).each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| return false if instance_eval(&b) == false}; super; end", __FILE__, __LINE__)}
+        (Model::BEFORE_HOOKS - [:before_save, :before_destroy]).each do |h|
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{h}
+              model.hook_blocks(:#{h}) do |b|
+                if instance_eval(&b) == false
+                  Sequel::Deprecation.deprecate("Having #{h} hook block return false to stop evaluation of further #{h} hook blocks", "Instead, call cancel_action inside #{h} hook block")
+                  return false
+                end
+              end
+              super
+            end
+          END
+        end
         (Model::AFTER_HOOKS - [:after_save, :after_destroy, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]).each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
 
         def after_destroy
@@ -146,7 +174,10 @@ module Sequel
 
         def before_destroy
           model.hook_blocks(:before_destroy) do |b|
-            return false if instance_eval(&b) == false
+            if instance_eval(&b) == false
+              Sequel::Deprecation.deprecate("Having before_destory hook block return false to stop evaluation of further before_destroy hook blocks", "Instead, call cancel_action inside before_destroy hook block")
+              return false
+            end
           end
           super
           if model.has_hooks?(:after_destroy_rollback)
@@ -156,7 +187,10 @@ module Sequel
 
         def before_save
           model.hook_blocks(:before_save) do |b|
-            return false if instance_eval(&b) == false
+            if instance_eval(&b) == false
+              Sequel::Deprecation.deprecate("Having before_save hook block return false to stop evaluation of further before_save hook blocks", "Instead, call cancel_action inside before_save hook block")
+              return false
+            end
           end
           super
           if model.has_hooks?(:after_rollback)

data/lib/sequel/plugins/instance_hooks.rb

@@ -32,40 +32,88 @@ module Sequel
       BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
       AFTER_HOOKS = Sequel::Model::AFTER_HOOKS
       HOOKS = BEFORE_HOOKS + AFTER_HOOKS
+      # SEQUEL5: Remove
+      DEPRECATION_REPLACEMENTS = {
+        :after_commit=>"Use obj.after_save_hook{obj.db.after_commit{}} instead",
+        :after_destroy_commit=>"Use obj.after_destroy_hook{obj.db.after_commit{}} instead",
+        :after_destroy_rollback=>"Use obj.before_destroy_hook{obj.db.after_rollback{}} instead",
+        :after_rollback=>"Use obj.before_save_hook{obj.db.after_rollback{}} instead"
+      }.freeze
 
       module InstanceMethods 
         HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
           def #{h}_hook(&block)
+            #{"Sequel::Deprecation.deprecate('Sequel::Model##{h}_hook in the instance_hooks plugin', #{DEPRECATION_REPLACEMENTS[h].inspect})" if DEPRECATION_REPLACEMENTS[h]}
             raise Sequel::Error, "can't add hooks to frozen object" if frozen?
             add_instance_hook(:#{h}, &block)
             self
           end
         END
         
-        BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
-        (AFTER_HOOKS - [:after_validation, :after_save]).each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+        (BEFORE_HOOKS - [:before_destroy, :before_save]).each{|h| class_eval("def #{h}; (@instance_hooks && run_before_instance_hooks(:#{h}) == false) ? false : super end", __FILE__, __LINE__)}
+        (AFTER_HOOKS - [:after_validation, :after_save, :after_destroy, :after_commit, :after_destroy_commit, :after_destroy_rollback, :after_rollback]).each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
           def #{h}
             super
+            return unless @instance_hooks
             run_after_instance_hooks(:#{h})
             @instance_hooks.delete(:#{h})
             @instance_hooks.delete(:#{h.to_s.sub('after', 'before')})
           end
         END
 
-        # Run after validation hooks, without clearing the validation hooks.
+        # Run after destroy instance hooks.
+        def after_destroy
+          super
+          return unless @instance_hooks
+          if ad = @instance_hooks[:after_destroy_commit]
+            db.after_commit{ad.each(&:call)}
+          end
+          run_after_instance_hooks(:after_destroy)
+          @instance_hooks.delete(:after_destroy)
+          @instance_hooks.delete(:before_destroy)
+          @instance_hooks.delete(:after_destroy_commit)
+          @instance_hooks.delete(:after_destroy_rollback)
+        end
+
+        # Run after validation instance hooks.
         def after_validation
           super
+          return unless @instance_hooks
           run_after_instance_hooks(:after_validation)
         end
         
-        # Run after save hooks, clearing both the save and validation hooks.
+        # Run after save instance hooks.
         def after_save
           super
+          return unless @instance_hooks
+          if (ac = @instance_hooks[:after_commit])
+            db.after_commit{ac.each(&:call)}
+          end
           run_after_instance_hooks(:after_save)
           @instance_hooks.delete(:after_save)
           @instance_hooks.delete(:before_save)
           @instance_hooks.delete(:after_validation)
           @instance_hooks.delete(:before_validation)
+          @instance_hooks.delete(:after_commit)
+          @instance_hooks.delete(:after_rollback)
+        end
+
+        # Run before_destroy instance hooks.
+        def before_destroy
+          return super unless @instance_hooks
+          if adr = @instance_hooks[:after_destroy_rollback]
+            db.after_rollback{adr.each(&:call)}
+          end
+          run_before_instance_hooks(:before_destroy) == false ? false : super
+        end
+
+        # Run before_save instance hooks.
+        def before_save
+          return super unless @instance_hooks
+          if ar = @instance_hooks[:after_rollback]
+            db.after_rollback{ar.each(&:call)}
+          end
+          run_before_instance_hooks(:before_save) == false ? false : super
         end
         
         private
@@ -91,7 +139,12 @@ module Sequel
         # Run all hook blocks of the given hook type.  If a hook block returns false,
         # immediately return false without running the remaining blocks.
         def run_before_instance_hooks(hook)
-          instance_hooks(hook).each{|b| return false if b.call == false}
+          instance_hooks(hook).each do |b|
+            if b.call == false
+              Sequel::Deprecation.deprecate("Having #{hook} instance hook block return false to stop evaluation of further #{hook} instance hook blocks", "Instead, call cancel_action inside #{hook} instance hook block")
+              return false
+            end
+          end
         end
       end
     end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -38,9 +38,14 @@ module Sequel
       end
       
       module ClassMethods
-        # Module to store the lazy attribute getter methods, so they can
-        # be overridden and call super to get the lazy attribute behavior
-        attr_accessor :lazy_attributes_module
+        def lazy_attributes_module
+          Sequel::Deprecation.deprecate('Sequel::Model.lazy_attributes_module', 'There is no replacement')
+          @lazy_attributes_module
+        end
+        def lazy_attributes_module=(v)
+          Sequel::Deprecation.deprecate('Sequel::Model.lazy_attributes_module=', 'There is no replacement')
+          @lazy_attributes_module= v
+        end
 
         # Freeze lazy attributes module when freezing model class.
         def freeze
@@ -66,8 +71,8 @@ module Sequel
         # :dataset :: The base dataset to use for the lazy attribute lookup
         # :table :: The table name to use to qualify the attribute and primary key columns.
         def define_lazy_attribute_getter(a, opts=OPTS)
-          include(self.lazy_attributes_module ||= Module.new) unless lazy_attributes_module
-          lazy_attributes_module.class_eval do
+          include(@lazy_attributes_module ||= Module.new) unless @lazy_attributes_module
+          @lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.has_key?(a) && !new?
                 lazy_attribute_lookup(a, opts)

data/lib/sequel/plugins/nested_attributes.rb

@@ -81,9 +81,14 @@ module Sequel
       end
       
       module ClassMethods
-        # Module to store the nested_attributes setter methods, so they can
-        # call be overridden and call super to get the default behavior
-        attr_accessor :nested_attributes_module
+        def nested_attributes_module
+          Sequel::Deprecation.deprecate('Sequel::Model.nested_attributes_module', 'There is no replacement')
+          @nested_attributes_module
+        end
+        def nested_attributes_module=(v)
+          Sequel::Deprecation.deprecate('Sequel::Model.nested_attributes_module=', 'There is no replacement')
+          @nested_attributes_module = v
+        end
         
         # Freeze nested_attributes_module when freezing model class.
         def freeze
@@ -117,7 +122,7 @@ module Sequel
         #
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
-          include(self.nested_attributes_module ||= Module.new) unless nested_attributes_module
+          include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
           opts = associations.last.is_a?(Hash) ? associations.pop : {}
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
@@ -133,7 +138,7 @@ module Sequel
         # Add a nested attribute setter method to a module included in the
         # class.
         def def_nested_attribute_method(reflection)
-          nested_attributes_module.class_eval do
+          @nested_attributes_module.class_eval do
             define_method("#{reflection[:name]}_attributes=") do |v|
               set_nested_attributes(reflection[:name], v)
             end

data/lib/sequel/plugins/prepared_statements.rb

@@ -32,6 +32,7 @@ module Sequel
 
       # Setup the datastructure used to hold the prepared statements in the model.
       def self.apply(model)
+        # SEQUEL5: Drop Support for :fixed/:lookup_sql SQL
         model.instance_variable_set(:@prepared_statements, {:insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{}}.freeze)
       end
 
@@ -66,6 +67,7 @@ module Sequel
 
         # Return a prepared statement that can be used to delete a row from this model's dataset.
         def prepared_delete
+          # SEQUEL5: Remove
           cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}
         end
 
@@ -84,11 +86,13 @@ module Sequel
 
         # Return a prepared statement that can be used to lookup a row solely based on the primary key.
         def prepared_lookup
+          # SEQUEL5: Remove
           cached_prepared_statement(:fixed, :lookup){prepare_explicit_statement(filter(prepared_statement_key_array(primary_key)), :first)}
         end
 
         # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
         def prepared_refresh
+          # SEQUEL5: Remove
           cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).where(prepared_statement_key_array(primary_key)), :first)}
         end
 
@@ -122,6 +126,7 @@ module Sequel
         # Use a prepared statement to query the database for the row matching the given primary key.
         def primary_key_lookup(pk)
           return super unless use_prepared_statements_for_pk_lookup?
+          # SEQUEL5: Remove
           prepared_lookup.call(primary_key_hash(pk))
         end
 
@@ -150,6 +155,7 @@ module Sequel
 
         # Use a prepared statement to delete the row.
         def _delete_without_checking
+          # SEQUEL5: Remove
           if use_prepared_statements_for?(:delete)
             _set_prepared_statement_server(model.send(:prepared_delete)).call(pk_hash)
           else
@@ -180,6 +186,7 @@ module Sequel
 
         # Use a prepared statement to refresh this model's column values.
         def _refresh_get(ds)
+          # SEQUEL5: Remove
           if use_prepared_statements_for?(:refresh)
             _set_prepared_statement_server(model.send(:prepared_refresh)).call(pk_hash)
           else