sequel 4.26.0 → 5.37.0

data/lib/sequel/model/dataset_module.rb

@@ -1,21 +1,21 @@
+# frozen-string-literal: true
+
 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
@@ -23,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,5 +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

@@ -1,10 +1,10 @@
+# frozen-string-literal: true
+
 module Sequel
   class Model
     # 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'
@@ -38,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 : "#{Array(att).join(' and ')} #{e}")}
           m
         end
       end

data/lib/sequel/model/exceptions.rb

@@ -1,29 +1,34 @@
+# 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
 
-    def initialize(message, model=nil)
+    def initialize(message=nil, model=nil)
       @model = model
       super(message)
     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
@@ -33,7 +38,7 @@ module Sequel
     # The Sequel::Model::Errors object related to this exception.
     attr_reader :errors
 
-    def initialize(errors)
+    def initialize(errors=nil)
       if errors.is_a?(Sequel::Model)
         @model = errors
         errors = @model.errors
@@ -47,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
@@ -23,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
@@ -103,7 +92,7 @@ module Sequel
       (@uncountables << words).flatten!
     end
 
-    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+    instance_exec(&DEFAULT_INFLECTIONS_PROC)
 
     private
 
@@ -111,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
   
@@ -121,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
   
@@ -129,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.
@@ -155,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   # Empty namespace that plugins should use to store themselves,
   # so they can be loaded via Model.plugin.
@@ -23,9 +25,13 @@ 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__)
+        mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
       end
     end
 
@@ -35,15 +41,120 @@ 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)
+      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
+
+      # 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/plugins/accessed_columns.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The accessed_columns plugin records which columns have been

data/lib/sequel/plugins/active_model.rb

@@ -1,7 +1,9 @@
+# frozen-string-literal: true
+
 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+.
@@ -26,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
@@ -34,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
@@ -51,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.
@@ -63,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
@@ -84,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
@@ -91,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # Adds an after_initialize hook to models, called after initializing
@@ -13,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