sequel 4.36.0 → 5.61.0

data/lib/sequel/model/dataset_module.rb

@@ -3,21 +3,19 @@
 module Sequel
   class Model
     # This Module subclass is used by Model.dataset_module
-    # to add dataset methods to classes.  It adds a couple
-    # of features standard Modules, allowing you to use
-    # the same subset method you can call on Model, as well
-    # as making sure that public methods added to the module
-    # automatically have class methods created for them.
-    class DatasetModule < ::Module
+    # to add dataset methods to classes.  In addition to the
+    # methods offered by Dataset::DatasetModule, it also
+    # automatically creates class methods for public dataset
+    # methods.
+    class DatasetModule < Dataset::DatasetModule
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model
       end
 
-      # Define a named filter for this dataset, see
-      # Model.subset for details.
+      # Alias for where.
       def subset(name, *args, &block)
-        @model.subset(name, *args, &block)
+        where(name, *args, &block)
       end
 
       private
@@ -25,8 +23,11 @@ module Sequel
       # Add a class method to the related model that
       # calls the dataset method of the same name.
       def method_added(meth)
-        @model.send(:def_model_dataset_method, meth)
+        @model.send(:def_model_dataset_method, meth) if public_method_defined?(meth)
+        super
       end
     end
+
+    @dataset_module_class = DatasetModule
   end
 end

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,8 +5,6 @@ module Sequel
     # Errors represents validation errors, a simple hash subclass
     # with a few convenience methods.
     class Errors < ::Hash
-      ATTRIBUTE_JOINER = ' and '.freeze
-
       # Adds an error for the given attribute.
       #
       #   errors.add(:name, 'is not valid') if name == 'invalid'
@@ -40,7 +38,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : full_message(att, e))}
           m
         end
       end
@@ -55,6 +53,15 @@ module Sequel
           v
         end
       end
+
+      private
+
+      # Create full error message to use for the given attribute (or array of attributes)
+      # and error message. This can be overridden for easier internalization.
+      def full_message(att, error_msg)
+        att = att.join(' and ') if att.is_a?(Array)
+        "#{att} #{error_msg}"
+      end
     end
   end
 end

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,19 +13,22 @@ module Sequel
     end
   end
 
-  # Alias for HookFailed, kept for backwards compatibility
-  BeforeHookFailed = HookFailed
-  
+  (
   # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
   # modify a single row.
   NoExistingObject = Class.new(Error)
+  ).name
   
+  (
   # Raised when an undefined association is used when eager loading.
   UndefinedAssociation = Class.new(Error)
+  ).name
 
+  (
   # Raised when a mass assignment method is called in strict mode with either a restricted column
   # or a column without a setter method.
   MassAssignmentRestriction = Class.new(Error)
+  ).name
   
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error
@@ -49,9 +52,4 @@ module Sequel
       end
     end
   end
-
-  # Call name on each class to set the name for the class, so it gets cached.
-  constants.map{|c| const_get(c)}.each do |c|
-    Class === c && c.name
-  end
 end

data/lib/sequel/model/inflections.rb

@@ -4,7 +4,7 @@ module Sequel
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
 
@@ -25,19 +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
-    CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
-    DASH = '-'.freeze
-    DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
-    EMPTY_STRING= ''.freeze
-    SLASH = '/'.freeze
-    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
-    UNDERSCORE = '_'.freeze
-    UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
-    UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
-    UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
-    UNDERSCORE_MODULE_REGEXP = /::/.freeze
-
     @plurals, @singulars, @uncountables = [], [], []
 
     class << self
@@ -105,7 +92,7 @@ module Sequel
       (@uncountables << words).flatten!
     end
 
-    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+    instance_exec(&DEFAULT_INFLECTIONS_PROC)
 
     private
 
@@ -113,7 +100,7 @@ module Sequel
     def camelize(s)
       s = s.to_s
       return s.camelize if s.respond_to?(:camelize)
-      s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
+      s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
       s
     end
   
@@ -123,7 +110,7 @@ module Sequel
     def constantize(s)
       s = s.to_s
       return s.constantize if s.respond_to?(:constantize)
-      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
   
@@ -131,7 +118,7 @@ module Sequel
     def demodulize(s)
       s = s.to_s
       return s.demodulize if s.respond_to?(:demodulize)
-      s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
+      s.gsub(/^.*::/, '')
     end
   
     # Returns the plural form of the word in the string.
@@ -157,8 +144,8 @@ module Sequel
     def underscore(s)
       s = s.to_s
       return s.underscore if s.respond_to?(:underscore)
-      s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
-        gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
+      s.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
     end
   end
 end

data/lib/sequel/model/plugins.rb

@@ -25,9 +25,15 @@ module Sequel
     # In the given module +mod+, define methods that are call the same method
     # on the dataset.  This is designed for plugins to define dataset methods
     # inside ClassMethods that call the implementations in DatasetMethods.
+    #
+    # This should not be called with untrusted input or method names that
+    # can't be used literally, since it uses class_eval.
     def self.def_dataset_methods(mod, meths)
       Array(meths).each do |meth|
         mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        # :nocov:
+        mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
     end
 
@@ -37,15 +43,123 @@ module Sequel
       mod.send(:define_method, :inherited_instance_variables) do ||
         super().merge!(hash)
       end
+      mod.send(:private, :inherited_instance_variables)
     end
 
     # Add method to +mod+ that overrides set_dataset to call the method afterward.
     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
     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)
+      model.send(:alias_method, meth, 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
+        else
+          raise Error, "invalid arg_type passed to _define_sequel_method_arg_numbers: #{arg_type}"
+        end
+      end
+      arity = callable.arity
+      if arity < 0
+        arity = arity.abs - 1
+      end
+      required_args = arity
+      arity -= 1 if keyword == :required
+
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
+
+      [required_args, optional_args, rest, keyword]
+    end
+    private_class_method :_define_sequel_method_arg_numbers
   end
 end

data/lib/sequel/model.rb

@@ -1,22 +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
-    Model.cache_anonymous_models
-  end
-
-  # Delegate to Sequel::Model, only for backwards compatibility.
-  def self.cache_anonymous_models=(v)
-    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
@@ -29,77 +20,30 @@ module Sequel
   class Model
     OPTS = Sequel::OPTS
 
-    # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
-    # of classes when dealing with code reloading.
-    ANONYMOUS_MODEL_CLASSES = @Model_cache = {}
-
-    # Mutex protecting access to ANONYMOUS_MODEL_CLASSES
-    ANONYMOUS_MODEL_CLASSES_MUTEX = @Model_mutex = Mutex.new
-
-    # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS +
-      [:each_server]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]
-    
-    # Boolean settings that can be modified at the global, class, or instance level.
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
-      :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_after_commit_rollback, :use_transactions]
-
-    # Hooks that are called before an action.  Can return false to not do the action.  When
-    # overriding these, it is recommended to call +super+ as the last line of your method,
-    # so later hooks are called before earlier hooks.
-    BEFORE_HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation]
-
-    # Hooks that are called after an action.  When overriding these, it is recommended to call
-    # +super+ on the first line of your method, so later hooks are called after earlier hooks.
-    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy,
-      :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
-
-    # Hooks that are called around an action.  If overridden, these methods must call super
-    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
-    # raised by the code they wrap or ensure that some behavior is executed no matter what.
-    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
-
-    # 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_HOOKS + AFTER_HOOKS
-
-    # Class instance variables that are inherited in subclasses.  If the value is <tt>:dup</tt>, dup is called
-    # on the superclass's instance variable when creating the instance variable in the subclass.
-    # If the value is +nil+, the superclass's instance variable is used directly in the subclass.
-    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup,
-      :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
-      :@raise_on_save_failure=>nil, :@require_modification=>nil, 
-      :@restricted_columns=>:dup, :@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, :@Model_mutex=>nil}
-
-    # Regular expression that determines if a method name is normal in the sense that
-    # it could be used literally in ruby code without using send.  Used to
-    # avoid problems when using eval with a string to define methods.
-    NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
-
-    # Regular expression that determines if the method is a valid setter name
-    # (i.e. it ends with =).
-    SETTER_METHOD_REGEXP = /=\z/
+    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
     @cache_anonymous_models = true
     @db = nil
     @db_schema = nil
     @dataset = nil
     @dataset_method_modules = []
-    @default_eager_limit_strategy = true
     @default_set_fields_options = {}
-    @finders = {}
-    @finder_loaders = {}
     @overridable_methods_module = nil
     @fast_pk_lookup_sql = nil
     @fast_instance_delete_sql = nil
@@ -108,28 +52,34 @@ module Sequel
     @raise_on_save_failure = true
     @raise_on_typecast_failure = false
     @require_modification = nil
-    @require_valid_table = false
+    @require_valid_table = true
     @restrict_primary_key = true
-    @restricted_columns = nil
     @setter_methods = nil
     @simple_pk = nil
     @simple_table = nil
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
-    @use_after_commit_rollback = true
     @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"
+    # :nocov:
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
-      Sequel.require 'associations', 'model'
+    # :nocov:
+      require_relative 'model/associations'
       plugin Model::Associations
     end
 
-    # 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).grep(SETTER_METHOD_REGEXP)
-
     def_Model(::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
   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+.
@@ -28,6 +28,14 @@ module Sequel
 
       module ClassMethods
         include ::ActiveModel::Naming
+
+        # Cache model_name and to_partial path value before freezing.
+        def freeze
+          model_name
+          _to_partial_path
+
+          super
+        end
         
         # Class level cache for to_partial_path.
         def _to_partial_path
@@ -36,9 +44,6 @@ module Sequel
       end
 
       module InstanceMethods
-        # The default string to join composite primary keys with in to_param.
-        DEFAULT_TO_PARAM_JOINER = '-'.freeze
-      
         # Record that an object was destroyed, for later use by
         # destroyed?
         def after_destroy
@@ -46,13 +51,6 @@ module Sequel
           @destroyed = true
         end
 
-        # Mark current instance as destroyed if the transaction in which this
-        # instance is created is rolled back.
-        def before_create
-          db.after_rollback{@destroyed = true}
-          super
-        end
-
         # Return ::ActiveModel::Name instance for the class.
         def model_name
           model.model_name
@@ -60,7 +58,16 @@ module Sequel
 
         # False if the object is new? or has been destroyed, true otherwise.
         def persisted?
-          !new? && @destroyed != true
+          return false if new?
+          return false if defined?(@destroyed)
+
+          if defined?(@rollback_checker)
+            if @rollback_checker.call
+              return false
+            end
+          end
+          
+          true
         end
         
         # An array of primary key values, or nil if the object is not persisted.
@@ -72,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
@@ -93,6 +100,15 @@ module Sequel
         
         private
 
+        # For new objects, add a rollback checker to check if the transaction
+        # in which this instance is created is rolled back.
+        def _save(opts)
+          if new? && db.in_transaction?(opts)
+            @rollback_checker = db.rollback_checker(opts)
+          end
+          super
+        end
+
         # Use ActiveModel compliant errors class.
         def errors_class
           Errors
@@ -100,7 +116,7 @@ module Sequel
         
         # The string to use to join composite primary key param strings.
         def to_param_joiner
-          DEFAULT_TO_PARAM_JOINER
+          '-'
         end
       end
     end

data/lib/sequel/plugins/after_initialize.rb

@@ -15,7 +15,7 @@ module Sequel
     module AfterInitialize
       module ClassMethods
         # Call after_initialize for model objects loaded from the database.
-        def call(h={})
+        def call(_)
           v = super
           v.after_initialize
           v