sequel 4.49.0 → 5.3.0

data/lib/sequel/model/default_inflections.rb

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 module Sequel
-  # Proc that is instance evaled to create the default inflections for both the
+  # Proc that is instance_execed to create the default inflections for both the
   # model inflector and the inflector extension.
   DEFAULT_INFLECTIONS_PROC = proc do
     plural(/$/, 's')

data/lib/sequel/model/errors.rb

@@ -5,9 +5,6 @@ module Sequel
     # Errors represents validation errors, a simple hash subclass
     # with a few convenience methods.
     class Errors < ::Hash
-      ATTRIBUTE_JOINER = ' and '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ATTRIBUTE_JOINER)
-
       # Adds an error for the given attribute.
       #
       #   errors.add(:name, 'is not valid') if name == 'invalid'

data/lib/sequel/model/exceptions.rb

@@ -1,8 +1,8 @@
 # frozen-string-literal: true
 
 module Sequel
-  # Exception class raised when +raise_on_save_failure+ is set and a before hook returns false
-  # or an around hook doesn't call super or yield.
+  # Exception class raised when +raise_on_save_failure+ is set and an action is canceled in a hook.
+  # or an around hook doesn't yield.
   class HookFailed < Error
     # The Sequel::Model instance related to this error.
     attr_reader :model
@@ -13,10 +13,6 @@ module Sequel
     end
   end
 
-  # Alias for HookFailed, kept for backwards compatibility
-  BeforeHookFailed = HookFailed
-  Sequel::Deprecation.deprecate_constant(self, :BeforeHookFailed)
-  
   (
   # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
   # modify a single row.

data/lib/sequel/model/inflections.rb

@@ -25,31 +25,6 @@ module Sequel
   # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
   # already have been loaded.
   module Inflections
-    CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :CAMELIZE_CONVERT_REGEXP)
-    CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :CAMELIZE_MODULE_REGEXP)
-    DASH = '-'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :DASH)
-    DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :DEMODULIZE_CONVERT_REGEXP)
-    EMPTY_STRING= ''.freeze
-    Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
-    SLASH = '/'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SLASH)
-    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :VALID_CONSTANT_NAME_REGEXP)
-    UNDERSCORE = '_'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE)
-    UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REGEXP1)
-    UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REGEXP2)
-    UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REPLACE)
-    UNDERSCORE_MODULE_REGEXP = /::/.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_MODULE_REGEXP)
-
     @plurals, @singulars, @uncountables = [], [], []
 
     class << self
@@ -117,7 +92,7 @@ module Sequel
       (@uncountables << words).flatten!
     end
 
-    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+    instance_exec(&DEFAULT_INFLECTIONS_PROC)
 
     private
 

data/lib/sequel/model/plugins.rb

@@ -46,6 +46,7 @@ module Sequel
     def self.after_set_dataset(mod, meth)
       mod.send(:define_method, :set_dataset) do |*a|
         r = super(*a)
+        # Allow calling private class methods as methods this specifies are usually private
         send(meth)
         r
       end

data/lib/sequel/model.rb

@@ -1,24 +1,13 @@
 # frozen-string-literal: true
 
-require 'sequel/core'
+require_relative 'core'
 
 module Sequel
-  # Delegate to Sequel::Model, only for backwards compatibility.
-  def self.cache_anonymous_models
-    Sequel::Deprecation.deprecate("Sequel.cache_anonymous_models", "Use Sequel::Model.cache_anonymous_models")
-    Model.cache_anonymous_models
-  end
-
-  # Delegate to Sequel::Model, only for backwards compatibility.
-  def self.cache_anonymous_models=(v)
-    Sequel::Deprecation.deprecate("Sequel.cache_anonymous_models=", "Use Sequel::Model.cache_anonymous_models=")
-    Model.cache_anonymous_models = v
-  end
-
   # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
   # model class is backed by a dataset instance, and many dataset methods can be
   # called directly on the class.  Model datasets return rows as model instances,
-  # which have fairly standard ORM instance behavior.
+  # which are wrappers around the underlying hash that allow easily updating or
+  # deleting the individual row.
   #
   # <tt>Sequel::Model</tt> is built completely out of plugins.  Plugins can override any class,
   # instance, or dataset method defined by a previous plugin and call super to get the default
@@ -31,47 +20,30 @@ module Sequel
   class Model
     OPTS = Sequel::OPTS
 
-    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server, :where_all, :where_each, :where_single_value]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases]
-    Sequel::Deprecation.deprecate_constant(self, :DATASET_METHODS)
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions, :use_after_commit_rollback]
-    Sequel::Deprecation.deprecate_constant(self, :BOOLEAN_SETTINGS)
-    BEFORE_HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation]
-    Sequel::Deprecation.deprecate_constant(self, :BEFORE_HOOKS)
-    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy, :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
-    Sequel::Deprecation.deprecate_constant(self, :AFTER_HOOKS)
-    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
-    Sequel::Deprecation.deprecate_constant(self, :AROUND_HOOKS)
-    NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
-    Sequel::Deprecation.deprecate_constant(self, :NORMAL_METHOD_NAME_REGEXP)
-    SETTER_METHOD_REGEXP = /=\z/
-    Sequel::Deprecation.deprecate_constant(self, :SETTER_METHOD_REGEXP)
-    ANONYMOUS_MODEL_CLASSES = @Model_cache = {}
-    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES)
-    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new
-    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES_MUTEX)
-    INHERITED_INSTANCE_VARIABLES = { :@allowed_columns=>:dup, :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil, :@raise_on_save_failure=>nil, :@require_modification=>nil, :@restrict_primary_key=>nil, :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil, :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil, :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil, :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil, :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup, :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil, :@cache_anonymous_models=>nil, :@dataset_module_class=>nil}
-    Sequel::Deprecation.deprecate_constant(self, :INHERITED_INSTANCE_VARIABLES)
-
-    # Empty instance methods to create that the user can override to get hook/callback behavior.
+    # Empty instance methods to create that the user can override.
     # Just like any other method defined by Sequel, if you override one of these, you should
-    # call +super+ to get the default behavior (while empty by default, they can also be defined
+    # call +super+ to get the default behavior (while empty by default, they are often overridden
     # by plugins).  See the {"Model Hooks" guide}[rdoc-ref:doc/model_hooks.rdoc] for
     # more detail on hooks.
-    HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation,
-      :after_create, :after_update, :after_save, :after_destroy, :after_validation,
-      :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback # SEQUEL5: Remove commit/rollback hooks
-    ]#.freeze # SEQUEL5
+    HOOKS = [
+      :after_create,
+      :after_destroy,
+      :after_save,
+      :after_update,
+      :after_validation,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_validation
+    ].freeze
 
-    @allowed_columns = nil # SEQUEL5: Remove
     @cache_anonymous_models = true
     @db = nil
     @db_schema = nil
     @dataset = nil
     @dataset_method_modules = []
-    @default_eager_limit_strategy = true
     @default_set_fields_options = {}
-    @finders = {} # SEQUEL5: Remove
-    @finder_loaders = {} # SEQUEL5: Remove
     @overridable_methods_module = nil
     @fast_pk_lookup_sql = nil
     @fast_instance_delete_sql = nil
@@ -80,7 +52,7 @@ module Sequel
     @raise_on_save_failure = true
     @raise_on_typecast_failure = false
     @require_modification = nil
-    @require_valid_table = nil
+    @require_valid_table = true
     @restrict_primary_key = true
     @setter_methods = nil
     @simple_pk = nil
@@ -88,12 +60,17 @@ module Sequel
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
-    @use_after_commit_rollback = nil
     @use_transactions = true
 
-    Sequel.require %w"default_inflections inflections plugins dataset_module base exceptions errors", "model"
+    require_relative "model/default_inflections"
+    require_relative "model/inflections"
+    require_relative "model/plugins"
+    require_relative "model/dataset_module"
+    require_relative "model/base"
+    require_relative "model/exceptions"
+    require_relative "model/errors"
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
-      Sequel.require 'associations', 'model'
+      require_relative 'model/associations'
       plugin Model::Associations
     end
 
@@ -101,18 +78,6 @@ module Sequel
 
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via +set+/+update+/+new+/etc..
-    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}#.freeze # SEQUEL5
-
-    # SEQUEL5: Remove
-    class DeprecatedColumnsUpdated # :nodoc:
-      def initialize(columns_updated)
-        @columns_updated = columns_updated
-      end
-
-      def method_missing(*args, &block)
-        Sequel::Deprecation.deprecate("Accessing @columns_updated directly", "Use the columns_updated plugin and switch to the columns_updated method")
-        @columns_updated.send(*args, &block)
-      end
-    end
+    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}.freeze
   end
 end

data/lib/sequel/plugins/active_model.rb

@@ -3,7 +3,7 @@
 require 'active_model'
 module Sequel
   module Plugins
-    # The ActiveModel plugin makes Sequel::Model objects
+    # The active_model plugin makes Sequel::Model objects
     # pass the ActiveModel::Lint tests, which should
     # hopefully mean full ActiveModel compliance.  This should
     # allow the full support of Sequel::Model objects in Rails 3+.
@@ -18,9 +18,6 @@ module Sequel
     #   # Make the Album class active_model compliant
     #   Album.plugin :active_model
     module ActiveModel
-      DEFAULT_TO_PARAM_JOINER = '-'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_TO_PARAM_JOINER)
-      
       # ActiveModel compliant error class
       class Errors < Sequel::Model::Errors
         # Add autovivification so that #[] always returns an array.
@@ -82,7 +79,7 @@ module Sequel
           end
         end
 
-        # With the ActiveModel plugin, Sequel model objects are already
+        # With the active_model plugin, Sequel model objects are already
         # compliant, so this returns self.
         def to_model
           self

data/lib/sequel/plugins/association_dependencies.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The AssociationDependencies plugin allows you do easily set up before and/or after destroy hooks
+    # The association_dependencies plugin allows you do easily set up before and/or after destroy hooks
     # for destroying, deleting, or nullifying associated model objects.  The following
     # association types support the following dependency actions:
     # 
@@ -18,21 +18,21 @@ module Sequel
     # and dependency action values.  You can provide the hash to the plugin call itself or
     # to the add_association_dependencies method:
     #
-    #   Business.plugin :association_dependencies, :address=>:delete
+    #   Business.plugin :association_dependencies, address: :delete
     #   # or:
     #   Artist.plugin :association_dependencies
-    #   Artist.add_association_dependencies :albums=>:destroy, :reviews=>:delete, :tags=>:nullify
+    #   Artist.add_association_dependencies albums: :destroy, reviews: :delete, tags: :nullify
     module AssociationDependencies
       # Mapping of association types to when the dependency calls should be made (either
       # :before for in before_destroy or :after for in after_destroy)
-      ASSOCIATION_MAPPING = {:one_to_many=>:before, :many_to_one=>:after, :many_to_many=>:before, :one_to_one=>:before}
+      ASSOCIATION_MAPPING = {:one_to_many=>:before, :many_to_one=>:after, :many_to_many=>:before, :one_to_one=>:before}.freeze
 
       # The valid dependence actions
-      DEPENDENCE_ACTIONS = [:delete, :destroy, :nullify]
+      DEPENDENCE_ACTIONS = [:delete, :destroy, :nullify].freeze
 
       # Initialize the association_dependencies hash for this model.
       def self.apply(model, hash=OPTS)
-        model.instance_eval{@association_dependencies = {:before_delete=>[], :before_destroy=>[], :before_nullify=>[], :after_delete=>[], :after_destroy=>[]}}
+        model.instance_exec{@association_dependencies = {:before_delete=>[], :before_destroy=>[], :before_nullify=>[], :after_delete=>[], :after_destroy=>[]}}
       end
 
       # Call add_association_dependencies with any dependencies given in the plugin call.
@@ -50,7 +50,7 @@ module Sequel
         attr_reader :association_dependencies
 
         # Add association dependencies to this model.  The hash should have association name
-        # symbol keys and dependency action symbol values (e.g. :albums=>:destroy).
+        # symbol keys and dependency action symbol values (e.g. albums: :destroy).
         def add_association_dependencies(hash)
           hash.each do |association, action|
             raise(Error, "Nonexistent association: #{association}") unless r = association_reflection(association)
@@ -60,15 +60,15 @@ module Sequel
             association_dependencies[:"#{time}_#{action}"] << if action == :nullify
               case type
               when :one_to_many , :many_to_many
-                proc{send(r.remove_all_method)}
+                proc{public_send(r[:remove_all_method])}
               when :one_to_one
-                proc{send(r.setter_method, nil)}
+                proc{public_send(r[:setter_method], nil)}
               else
                 raise(Error, "Can't nullify many_to_one associated objects: association: #{association}")
               end
             else
               raise(Error, "Can only nullify many_to_many associations: association: #{association}") if type == :many_to_many
-              r.dataset_method
+              r[:dataset_method]
             end
           end
         end
@@ -88,16 +88,16 @@ module Sequel
         # many_to_one associations.
         def after_destroy
           super
-          model.association_dependencies[:after_delete].each{|m| send(m).delete}
-          model.association_dependencies[:after_destroy].each{|m| send(m).destroy}
+          model.association_dependencies[:after_delete].each{|m| public_send(m).delete}
+          model.association_dependencies[:after_destroy].each{|m| public_send(m).destroy}
         end
 
         # Run the delete, destroy, and nullify association dependency actions for
         # *_to_many associations.
         def before_destroy
-          model.association_dependencies[:before_delete].each{|m| send(m).delete}
-          model.association_dependencies[:before_destroy].each{|m| send(m).destroy}
-          model.association_dependencies[:before_nullify].each{|p| instance_eval(&p)}
+          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)}
           super
         end
       end

data/lib/sequel/plugins/association_pks.rb

@@ -12,6 +12,8 @@ module Sequel
     #   artist.album_pks # [1, 2, 3]
     #   artist.album_pks = [2, 4]
     #   artist.album_pks # [2, 4]
+    #   artist.save
+    #   # Persist changes
     #
     # Note that it uses the singular form of the association name. Also note
     # that the setter both associates to new primary keys not in the assocation
@@ -22,18 +24,9 @@ module Sequel
     # not call any callbacks.  If you have any association callbacks,
     # you probably should not use the setter methods.
     #
-    # If an association uses the :delay_pks option, you can set the associated
-    # pks for new objects, and the setting will not be persisted until after the
-    # object has been created in the database.  Additionally, if an association
-    # uses the :delay_pks=>:always option, you can set the associated pks for existing
-    # 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, changes to the association will not happen until the object
+    # is saved.  However, using the delay_pks: false option, you can have the
+    # changes made immediately when the association_pks setter method is called.
     #
     # 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.
@@ -95,7 +88,7 @@ module Sequel
               rpk = opts.associated_class.primary_key
               opts.associated_dataset.
                 naked.where(cond).
-                select_map(Sequel.send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
+                select_map(Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
             end
           elsif clpk
             lambda do
@@ -111,7 +104,7 @@ module Sequel
           if !opts[:read_only] && !join_associated_table
             opts[:pks_setter] = lambda do |pks|
               if pks.empty?
-                send(opts.remove_all_method)
+                public_send(opts[:remove_all_method])
               else
                 checked_transaction do
                   if clpk
@@ -146,13 +139,13 @@ module Sequel
           key = opts[:key]
 
           opts[:pks_getter] = lambda do
-            send(opts.dataset_method).select_map(opts.associated_class.primary_key)
+            public_send(opts[:dataset_method]).select_map(opts.associated_class.primary_key)
           end
 
           unless opts[:read_only]
             opts[:pks_setter] = lambda do |pks|
               if pks.empty?
-                send(opts.remove_all_method)
+                public_send(opts[:remove_all_method])
               else
                 primary_key = opts.associated_class.primary_key
                 pkh = {primary_key=>pks}
@@ -170,7 +163,7 @@ module Sequel
                 end
 
                 checked_transaction do
-                  ds = send(opts.dataset_method)
+                  ds = public_send(opts.dataset_method)
                   ds.unfiltered.where(pkh).update(h)
                   ds.exclude(pkh).update(nh)
                 end
@@ -207,10 +200,10 @@ module Sequel
         # If the receiver is a new object, return any saved
         # pks, or an empty array if no pks have been saved.
         def _association_pks_getter(opts)
-          delay = opts[:delay_pks]
+          delay = opts.fetch(:delay_pks, true)
           if new? && delay
             (@_association_pks ||= {})[opts[:name]] ||= []
-          elsif delay == :always && @_association_pks && (objs = @_association_pks[opts[:name]])
+          elsif delay && @_association_pks && (objs = @_association_pks[opts[:name]])
             objs
           else
             instance_exec(&opts[:pks_getter])
@@ -219,7 +212,7 @@ module Sequel
 
         # Update which objects are associated to the receiver.
         # If the receiver is a new object, save the pks
-        # so the update can happen after the received has been saved.
+        # so the update can happen after the receiver has been saved.
         def _association_pks_setter(opts, pks)
           if pks.nil?
             case opts[:association_pks_nil]
@@ -234,17 +227,10 @@ module Sequel
 
           pks = convert_pk_array(opts, 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)
+          if opts.fetch(:delay_pks, true)
             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

@@ -37,7 +37,7 @@ module Sequel
     #     :arguments => [2],
     #     :block => {|x| 3},
     #     :instance => artist,
-    #     :reflection => {:name=>:albums} # AssociationReflection instance 
+    #     :reflection => AssociationReflection instance,
     #     :proxy_argument => 1,
     #     :proxy_block => {|ds| ds}
     #   }
@@ -51,7 +51,7 @@ module Sequel
     #   Album.plugin :association_proxies
     module AssociationProxies
       def self.configure(model, &block)
-        model.instance_eval do
+        model.instance_exec do
           @association_proxy_to_dataset = block if block
           @association_proxy_to_dataset ||= AssociationProxy::DEFAULT_PROXY_TO_DATASET
         end
@@ -80,11 +80,11 @@ module Sequel
         # is an array method, otherwise call the method on the association's dataset.
         def method_missing(meth, *args, &block)
           v = if @instance.model.association_proxy_to_dataset.call(:method=>meth, :arguments=>args, :block=>block, :instance=>@instance, :reflection=>@reflection, :proxy_argument=>@proxy_argument, :proxy_block=>@proxy_block)
-            @instance.send(@reflection.dataset_method)
+            @instance.public_send(@reflection[:dataset_method])
           else
             @instance.send(:load_associated_objects, @reflection, @proxy_argument, &@proxy_block)
           end
-          v.send(meth, *args, &block)
+          v.public_send(meth, *args, &block)
         end
       end
 
@@ -100,9 +100,8 @@ module Sequel
         # directly.
         def def_association_method(opts)
           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)
+            association_module_def(opts.association_method, opts) do |dynamic_opts=OPTS, &block|
+              AssociationProxy.new(self, opts, dynamic_opts, &block)
             end
           else
             super

data/lib/sequel/plugins/auto_validations.rb

@@ -33,7 +33,7 @@ module Sequel
     # By default, the plugin uses a not_null validation for NOT NULL columns, but that
     # can be changed to a presence validation using an option:
     #
-    #   Model.plugin :auto_validations, :not_null=>:presence
+    #   Model.plugin :auto_validations, not_null: :presence
     #
     # This is useful if you want to enforce that NOT NULL string columns do not
     # allow empty values.
@@ -60,7 +60,7 @@ module Sequel
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
 
       def self.apply(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           plugin :validation_helpers
           @auto_validate_presence = false
           @auto_validate_not_null_columns = []
@@ -81,7 +81,7 @@ module Sequel
 
       # Setup auto validations for the model if it has a dataset.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           setup_auto_validations if @dataset
           if opts[:not_null] == :presence
             @auto_validate_presence = true
@@ -149,7 +149,7 @@ module Sequel
           when :types
             @auto_validate_types = false
           else
-            send("auto_validate_#{type}_columns").clear
+            public_send("auto_validate_#{type}_columns").clear
           end
         end
 

data/lib/sequel/plugins/before_after_save.rb

@@ -2,50 +2,7 @@
 
 module Sequel
   module Plugins
-    # The before_after_save plugin reorders some internal
-    # Sequel operations so they happen before after_create,
-    # after_update, and after_save are called, instead of
-    # after.  These operations are:
-    # 
-    # * Resetting the explicit modified flag
-    # * Refreshing the model or clearing changed columns after creation
-    #
-    # This behavior will become the default in Sequel 5.
-    #
-    # Usage:
-    #
-    #   # Make all model subclasses perform the operations before after_save
-    #   Sequel::Model.plugin :before_after_save
-    #
-    #   # Make the Album class perform the operations before after_save
-    #   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.
-        def _after_create(pk)
-          super
-          @modified = false
-          pk ? _save_refresh : changed_columns.clear
-        end
-
-        # Don't refresh or reset modified flag, as it was already done.
-        def _after_save(pk)
-          if @was_new
-            @was_new = nil
-          else
-            @columns_updated = nil
-          end
-        end
-
-        # Refresh and reset modified flag right after UPDATE query.
-        def _after_update
-          super
-          @modified = false
-        end
-      end
     end
   end
 end

data/lib/sequel/plugins/blacklist_security.rb

@@ -41,12 +41,12 @@ module Sequel
         # want not to be used during mass assignment, they need to be listed here as well (without the =).
         #
         # It's generally a bad idea to rely on a blacklist approach for security.  Using a whitelist
-        # approach such as set_allowed_columns or the instance level set_only or set_fields methods
+        # approach such as the whitelist_security plugin or the set_fields methods
         # is usually a better choice.  So use of this method is generally a bad idea.
         #
         #   Artist.set_restricted_columns(:records_sold)
-        #   Artist.set(:name=>'Bob', :hometown=>'Sactown') # No Error
-        #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
+        #   Artist.set(name: 'Bob', hometown: 'Sactown') # No Error
+        #   Artist.set(name: 'Bob', records_sold: 30000) # Error
         def set_restricted_columns(*cols)
           clear_setter_methods_cache
           @restricted_columns = cols
@@ -58,7 +58,8 @@ module Sequel
         # restricted_columns.
         def get_setter_methods
           meths = super
-          if !(respond_to?(:allowed_columns) && allowed_columns) && restricted_columns
+          #if !(respond_to?(:allowed_columns) && allowed_columns) && restricted_columns
+          if (!defined?(::Sequel::Plugins::WhitelistSecurity) || !plugins.include?(::Sequel::Plugins::WhitelistSecurity) || !allowed_columns) && restricted_columns
             meths -= restricted_columns.map{|x| "#{x}="}
           end
           meths
@@ -67,20 +68,20 @@ module Sequel
 
       module InstanceMethods
         # Set all values using the entries in the hash, except for the keys
-        # given in except.  You should probably use +set_fields+ or +set_only+
+        # given in except.  You should probably use +set_fields+
         # instead of this method, as blacklist approaches to security are a bad idea.
         #
-        #   artist.set_except({:name=>'Jim'}, :hometown)
+        #   artist.set_except({name: 'Jim'}, :hometown)
         #   artist.name # => 'Jim'
         def set_except(hash, *except)
           set_restricted(hash, ExceptionList.new(except.flatten))
         end
     
         # Update all values using the entries in the hash, except for the keys
-        # given in except.  You should probably use +update_fields+ or +update_only+
+        # given in except.  You should probably use +update_fields+
         # instead of this method, as blacklist approaches to security are a bad idea.
         #
-        #   artist.update_except({:name=>'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        #   artist.update_except({name: 'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
         def update_except(hash, *except)
           update_restricted(hash, ExceptionList.new(except.flatten))
         end