sequel 5.108.0 → 5.110.0

data/lib/sequel/extensions/string_date_time.rb

@@ -22,14 +22,17 @@ class String
 
   # Converts a string into a DateTime object.
   def to_datetime
-    DateTime.parse(self, Sequel.convert_two_digit_years)
-  rescue => e
-    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+    Sequel::Deprecation.deprecate("String#to_datetime is deprecated and will be removed in Sequel 6.")
+    begin
+      DateTime.parse(self, Sequel.convert_two_digit_years)
+    rescue => e
+      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+    end
   end
 
   # Converts a string into a Time or DateTime object, depending on the
   # value of Sequel.datetime_class
-  def to_sequel_time
+  def to_sequel_time # SEQUEL6: Simplify making an alias to to_time
     if Sequel.datetime_class == DateTime
       DateTime.parse(self, Sequel.convert_two_digit_years)
     else

data/lib/sequel/extensions/symbol_aref.rb

@@ -15,41 +15,21 @@
 #
 #   Sequel.extension :symbol_aref
 #
-# If you are using Ruby 2+, and you would like to use refinements, there
-# is a refinement version of this in the symbol_aref_refinement extension.
+# There is a refinement version of this in the symbol_aref_refinement extension.
 #
 # Related module: Sequel::SymbolAref
 
-if RUBY_VERSION >= '2.0'
-  module Sequel::SymbolAref
-    def [](v)
-      case v
-      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
-        Sequel::SQL::QualifiedIdentifier.new(self, v)
-      else
-        super
-      end
+module Sequel::SymbolAref
+  def [](v)
+    case v
+    when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+      Sequel::SQL::QualifiedIdentifier.new(self, v)
+    else
+      super
     end
   end
+end
 
-  class Symbol
-    prepend Sequel::SymbolAref
-  end
-# simplecov:disable
-else
-  class Symbol
-    if method_defined?(:[])
-      alias_method :aref_before_sequel, :[] 
-    end
-
-    def [](v)
-      case v
-      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
-        Sequel::SQL::QualifiedIdentifier.new(self, v)
-      else
-        aref_before_sequel(v)
-      end
-    end
-  end
+class Symbol
+  prepend Sequel::SymbolAref
 end
-# simplecov:enable

data/lib/sequel/extensions/symbol_aref_refinement.rb

@@ -25,10 +25,7 @@
 #
 # Related module: Sequel::SymbolAref
 
-# simplecov:disable
-raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
-# simplecov:enable
-
+#
 module Sequel::SymbolAref
   refine Symbol do
     def [](v)

data/lib/sequel/extensions/symbol_as.rb

@@ -14,8 +14,7 @@
 #
 #   Sequel.extension :symbol_as
 #
-# If you are using Ruby 2+, and you would like to use refinements, there
-# is a refinement version of this in the symbol_as_refinement extension.
+# There is a refinement version of this in the symbol_as_refinement extension.
 
 # 
 class Symbol

data/lib/sequel/extensions/symbol_as_refinement.rb

@@ -23,10 +23,7 @@
 #
 # Related module: Sequel::SymbolAs
 
-# simplecov:disable
-raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
-# simplecov:enable
-
+#
 module Sequel::SymbolAs
   refine Symbol do
     def as(aliaz, columns=nil)
@@ -34,4 +31,3 @@ module Sequel::SymbolAs
     end
   end
 end
-

data/lib/sequel/model/base.rb

@@ -1188,7 +1188,7 @@ END
       # By default it calls send with the argument to get the value.  This can
       # be overridden if you have columns that conflict with existing
       # method names.
-      alias get_column_value send
+      define_method(:get_column_value, Kernel.instance_method(:send))
 
       # Set the value of the column.  Takes two arguments.  The first is a
       # symbol or string argument for the column name, suffixed with =.  The
@@ -1196,7 +1196,7 @@ END
       # with the argument to set the value.  This can be overridden if you have
       # columns that conflict with existing method names (unlikely for setter
       # methods, but possible).
-      alias set_column_value send
+      define_method(:set_column_value, Kernel.instance_method(:send))
 
       # Creates new instance and passes the given values to set.
       # If a block is given, yield the instance to the block.
@@ -1293,7 +1293,7 @@ END
       # self.class.
       #
       #   Artist.new.model # => Artist
-      alias_method :model, :class
+      define_method(:model, Kernel.instance_method(:class))
 
       # The autoincrementing primary key for this model object. Should be
       # overridden if you have a composite primary key with one part of it
@@ -2433,12 +2433,7 @@ END
     plugin self
     def_initialize_nil_instance_variables
 
-    singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
-    # simplecov:disable
-    if RUBY_VERSION >= '1.9.3'
-    # simplecov:enable
-      singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
-    end
+    singleton_class.send(:undef_method, :dup, :clone, :initialize_copy, :initialize_clone, :initialize_dup)
 
     # simplecov:disable
     if defined?(Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER) && Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER >= 11800

data/lib/sequel/plugins/caching.rb

@@ -29,6 +29,13 @@ module Sequel
     #
     # You should not use this plugin if you are using sharding and there are different
     # rows for the same primary key on different shards.
+    #
+    # Note that if you are using a composite key, and multiple columns in the composite
+    # key could potentially contain the character ",", you should override the
+    # +composite_cache_key+ class method to return an an unambiguous string identifying
+    # the specific primary key argument given. For consistency, if you would like to
+    # modify the cache key string used for scalar primary keys, you can override the
+    # +scalar_cache_key+ class method.
     # 
     # Usage:
     #
@@ -81,8 +88,26 @@ module Sequel
 
         # Return a key string for the given primary key.
         def cache_key(pk)
-          raise(Error, 'no primary key for this record') unless pk.is_a?(Array) ? pk.all? : pk
-          "#{cache_key_prefix}:#{Array(pk).join(',')}"
+          case pk
+          when Array
+            raise(Error, 'no primary key for this record') unless pk.all?
+            "#{cache_key_prefix}:#{composite_cache_key(pk)}"
+          else
+            raise(Error, 'no primary key for this record') unless pk
+            "#{cache_key_prefix}:#{scalar_cache_key(pk)}"
+          end
+        end
+
+        # Return an appropriate cache key string for a valid scalar primary key.
+        # By default, converts the primary key to a string.
+        def scalar_cache_key(pk)
+          pk.to_s
+        end
+
+        # Return an appropriate cache key string for a valid composite primary key.
+        # By default, joins with the parts of the compsite key with ",".
+        def composite_cache_key(pk)
+          pk.join(',')
         end
         
         Plugins.inherited_instance_variables(self, :@cache_store=>nil, :@cache_ttl=>nil, :@cache_ignore_exceptions=>nil)

data/lib/sequel/plugins/csv_serializer.rb

@@ -73,23 +73,12 @@ module Sequel
         end
       end
 
-      # Avoid keyword argument separation warnings on Ruby 2.7, while still
-      # being compatible with 1.9.
-      if RUBY_VERSION >= "2.0"
-        instance_eval(<<-END, __FILE__, __LINE__+1)
-          def self.csv_call(*args, opts, &block)
-            CSV.send(*args, **opts, &block)
-          end
-        END
-      else
-        # simplecov:disable
-        # :nodoc:
-        def self.csv_call(*args, opts, &block)
-          CSV.send(*args, opts, &block)
-        end
-        # :nodoc:
-        # simplecov:enable
+      # simplecov:disable
+      def self.csv_call(*args, opts, &block)
+        Sequel::Deprecation.deprecate("Sequel::Plugins::CsvSerializer.csv_call will be removed in Sequel 6.")
+        CSV.send(*args, **opts, &block)
       end
+      # simplecov:enable
 
       module ClassMethods
         # The default opts to use when serializing model objects to CSV
@@ -97,7 +86,7 @@ module Sequel
 
         # Attempt to parse an array of instances from the given CSV string
         def array_from_csv(csv, opts = OPTS)
-          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
+          CSV.parse(csv, **process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
@@ -147,7 +136,7 @@ module Sequel
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
         def from_csv(csv, opts = OPTS)
-          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
+          row = CSV.parse_line(csv, **model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -165,7 +154,7 @@ module Sequel
           opts = model.process_csv_serializer_opts(opts)
           headers = opts[:headers]
 
-          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+          CSV.generate(**model.process_csv_serializer_opts(opts)) do |csv|
             csv << headers.map{|k| public_send(k)}
           end
         end
@@ -184,7 +173,7 @@ module Sequel
           items = opts.delete(:array) || self
           headers = opts[:headers]
 
-          CsvSerializer.csv_call(:generate, opts) do |csv|
+          CSV.generate(**opts) do |csv|
             items.each do |object|
               csv << headers.map{|header| object.public_send(header)}
             end

data/lib/sequel/plugins/instance_filters.rb

@@ -80,6 +80,14 @@ module Sequel
           instance_filters << [args, block]
         end
       
+        # Clear instance filters when saving changes even if the
+        # object wasn't modified.
+        def save_changes(opts=OPTS)
+          ret = super
+          clear_instance_filters if ret.nil?
+          ret
+        end
+
         private
         
         # If there are any instance filters, make sure not to use the

data/lib/sequel/plugins/instance_hooks.rb

@@ -93,6 +93,25 @@ module Sequel
           super
         end
         
+        # Run and clear save/update/validation hooks when saving changes even if the
+        # object wasn't modified.
+        def save_changes(opts=OPTS)
+          ret = super
+          if ret.nil? && @instance_hooks
+            run_before_instance_hooks(:before_validation)
+            run_before_instance_hooks(:after_validation)
+            run_before_instance_hooks(:before_save)
+            run_before_instance_hooks(:before_update)
+            ret = super
+            run_before_instance_hooks(:after_update)
+            run_before_instance_hooks(:after_save)
+            [:before_validation, :after_validation, :before_save, :before_update, :after_update, :after_save].each do |type|
+              @instance_hooks.delete(type)
+            end
+          end
+          ret
+        end
+
         private
         
         # Add the block as an instance level hook.  For before hooks, add it to

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -22,6 +22,13 @@ module Sequel
     #
     #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
+    # By default, the plugin allows using the lock column setter method to
+    # either increase or decrease the lock column value. To prevent increases,
+    # which could potentially be used to skip an update when it update should
+    # be made, you can use the +:prevent_increase+ plugin option:
+    #
+    #     plugin :mssql_optimistic_locking, prevent_increase: true
+    #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking
       # Load the instance_filters plugin into the model.
@@ -32,6 +39,8 @@ module Sequel
       # Set the lock column
       def self.configure(model, opts=OPTS)
         model.lock_column = opts[:lock_column] || model.lock_column || :timestamp
+        # SEQUEL6: Make prevent_increase true by default
+        model.send(:prevent_lock_column_increase!) if opts[:prevent_increase]
       end
       
       module InstanceMethods

data/lib/sequel/plugins/optimistic_locking.rb

@@ -20,6 +20,13 @@ module Sequel
     #
     #     plugin :optimistic_locking, lock_column: :version
     #
+    # By default, the plugin allows using the lock column setter method to
+    # either increase or decrease the lock column value. To prevent increases,
+    # which could potentially be used to skip an update when it update should
+    # be made, you can use the +:prevent_increase+ plugin option:
+    #
+    #     plugin :optimistic_locking, prevent_increase: true
+    #
     # This plugin relies on the instance_filters plugin.
     module OptimisticLocking
       # Exception class raised when trying to update or destroy a stale object.
@@ -32,6 +39,8 @@ module Sequel
       # Set the lock column
       def self.configure(model, opts=OPTS)
         model.lock_column = opts[:lock_column] || model.lock_column || :lock_version
+        # SEQUEL6: Make prevent_increase true by default
+        model.send(:prevent_lock_column_increase!) if opts[:prevent_increase]
       end
 
       module InstanceMethods
@@ -42,9 +51,10 @@ module Sequel
         def _update_columns(columns)
           lc = model.lock_column
           lcv = get_column_value(lc)
-          columns[lc] = lcv + 1
+          new_lcv = columns[lc] = lcv + 1
           super
-          set_column_value("#{lc}=", lcv + 1)
+          set_column_value("#{lc}=", nil)
+          set_column_value("#{lc}=", new_lcv)
           changed_columns.delete(lc)
           nil
         end

data/lib/sequel/plugins/optimistic_locking_base.rb

@@ -12,6 +12,20 @@ module Sequel
       module ClassMethods
         # The column holding the version of the lock
         attr_accessor :lock_column
+
+        private
+
+        # Prevent increasing the value of the lock column. If the lock column
+        # has an existing value, do not allow setting a value that is higher
+        # than it.
+        def prevent_lock_column_increase!
+          lc = lock_column
+          define_method(:"#{lc}=") do |v|
+            unless v && (lv = send(lc)) && v > lv
+              super(v)
+            end
+          end
+        end
         
         Plugins.inherited_instance_variables(self, :@lock_column=>nil)
       end

data/lib/sequel/plugins/pg_xmin_optimistic_locking.rb

@@ -21,6 +21,13 @@ module Sequel
     # optimistic locking.  The disadvantage is that testing can be
     # more difficult if you are modifying the underlying row between
     # when a model is retrieved and when it is saved.
+
+    # By default, the plugin allows using the +xmin=+ setter method to
+    # either increase or decrease the lock value. To prevent increases,
+    # which could potentially be used to skip an update when it update should
+    # be made, you can use the +:prevent_increase+ plugin argument:
+    #
+    #     plugin :pg_xmin_optimistic_locking, prevent_increase: true
     #
     # This plugin may not work with the class_table_inheritance plugin.
     #
@@ -29,7 +36,7 @@ module Sequel
       WILDCARD = LiteralString.new('*').freeze
       
       # Define the xmin column accessor
-      def self.apply(model)
+      def self.apply(model, prevent_increase: false)
         model.instance_exec do
           plugin(:optimistic_locking_base)
           @lock_column = :xmin
@@ -39,9 +46,11 @@ module Sequel
 
       # Update the dataset to append the xmin column if it is usable
       # and there is a dataset for the model.
-      def self.configure(model)
+      def self.configure(model, prevent_increase: false)
         model.instance_exec do
           set_dataset(@dataset) if @dataset
+          # SEQUEL6: Make prevent_increase true by default
+          prevent_lock_column_increase! if prevent_increase
         end
       end
 

data/lib/sequel/plugins/select_on_skipped_update.rb

@@ -0,0 +1,63 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # This plugin changes the default model behavior so that for existing
+    # objects, if Model#save_changes skips the save as the object is not
+    # modified, or if the UPDATE query is skipped as there were no columns
+    # to update, Sequel will issue a SELECT query to make sure the object
+    # still exists. This is only done if require_modification is set for
+    # the object, so that these cases will raise the same error that
+    # Sequel would raise if the UPDATE require was run but did not modify
+    # a row.
+    # 
+    #   class Item < Sequel::Model
+    #     plugin :select_on_skipped_update
+    #   end
+    #
+    #   item = Item[1]
+    #
+    #   # Delete the item from the database
+    #   Item.where(id: 1).delete
+    #
+    #   # By default, this would return nil, but with the plugin,
+    #   # this raises Sequel::NoExistingRow.
+    #   item.save_changes
+    #
+    #   # By default, this would return the object without issuing the
+    #   # UPDATE query (as the columns to update is empty. With the plugin,
+    #   # this raises Sequel::NoExistingRow.
+    #   item.save(columns: [])
+    module SelectOnSkippedUpdate
+      COUNT = Sequel.function(:count).*.as(:count)
+      private_constant :COUNT
+
+      module InstanceMethods
+        # If an UPDATE statement was skipped as the object wasn't modified, run a SELECT query.
+        def save_changes(opts=OPTS)
+          ret = super
+          run_select_on_skipped_update if ret.nil? && require_modification
+          ret
+        end
+        
+        private
+
+        # If an UPDATE statement was skipped as there were no columns to update, run a SELECT query.
+        def _update_columns(columns)
+          ret = super
+          run_select_on_skipped_update if ret.nil? && columns.empty? && require_modification
+          ret
+        end
+
+        # Run a SELECT query on the dataset to determine whether the object still exists in the database.
+        # This will result in an exception if a single row is not modified.
+        def run_select_on_skipped_update
+          ds = _update_dataset
+          unless ds.select(COUNT).single_value! == 1
+            raise(NoMatchingRow, "Attempt to select object did not result in a single row modification")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -12,6 +12,11 @@ module Sequel
     # argument to the plugin) holds the class name as a string.  However,
     # you can override this by using the <tt>:model_map</tt> option and/or
     # the <tt>:key_map</tt> option.
+    #
+    # The +sti_key+ column can be set via mass assignment, just like any
+    # non-primary key column. Make sure to follow the recommendations in the
+    # {mass assignment guide}[rdoc-ref:doc/mass_assignment.rdoc]
+    # to ensure this column is not set with untrusted data.
     #   
     # You should only load this plugin in the parent class, not in the subclasses.
     #   
@@ -84,6 +89,7 @@ module Sequel
           @sti_key_array = nil
           @sti_key = key 
           @sti_dataset = dataset
+          @sti_root_class = self
           @sti_model_map = opts[:model_map] || lambda{|v| v if v && v != ''}
           @sti_key_map = if km = opts[:key_map]
             if km.is_a?(Hash)
@@ -150,7 +156,7 @@ module Sequel
         # This defaults to a lookup in the key map.
         attr_reader :sti_key_chooser
 
-        Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil)
+        Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil, :@sti_root_class=>nil)
 
         # Freeze STI information when freezing model class.  Note that
         # because of how STI works, you should not freeze an STI subclass
@@ -221,11 +227,23 @@ module Sequel
         # Return a class object.  If a class is given, return it directly.
         # Treat strings and symbols as class names.  If nil is given or
         # an invalid class name string or symbol is used, return self.
+        # If the class is valid but is not a subclass of the class that
+        # loaded the single_table_inheritance plugin, use the class that
+        # loaded the plugin.
         # Raise an error for other types.
         def sti_class(v)
           case v
           when String, Symbol
-            constantize(v) rescue self
+            begin
+              klass = constantize(v)
+              if Class === klass && @sti_root_class >= klass
+                klass
+              else
+                @sti_root_class
+              end
+            rescue
+              self
+            end
           when nil
             self
           when Class

data/lib/sequel/plugins/subset_conditions.rb

@@ -105,22 +105,11 @@ module Sequel
 
         private
 
-        if RUBY_VERSION >= '2'
-          # Backbone of #where_any and #where_all
-          def _where_any_all(meth, name, args)
-            ds = model.dataset
-            # #bind used here because the dataset module may not yet be included in the model's dataset
-            where(name, Sequel.send(meth, *args.map{|a| self.instance_method(:"#{a}_conditions").bind(ds).call}))
-          end
-        else
-          # Cannot bind module method to arbitrary objects in Ruby 1.9.
-          # simplecov:disable
-          def _where_any_all(meth, name, args)
-            ds = model.dataset.clone
-            ds.extend(self)
-            where(name, Sequel.send(meth, *args.map{|a| ds.send(:"#{a}_conditions")}))
-          end
-          # simplecov:enable
+        # Backbone of #where_any and #where_all
+        def _where_any_all(meth, name, args)
+          ds = model.dataset
+          # #bind used here because the dataset module may not yet be included in the model's dataset
+          where(name, Sequel.send(meth, *args.map{|a| self.instance_method(:"#{a}_conditions").bind(ds).call}))
         end
       end
     end

data/lib/sequel/plugins/throw_failures.rb

@@ -64,7 +64,7 @@ module Sequel
           end
         end
 
-        if RUBY_VERSION >= '2.2' && (!defined?(JRUBY_VERSION) || JRUBY_VERSION > '9.1')
+        if RUBY_VERSION >= '2.2' && (!defined?(JRUBY_VERSION) || JRUBY_VERSION.to_r > Rational('9.1'))
           # Throw HookFailed with the generated error.  If the throw is not
           # caught, just return the originally generated error.
           def hook_failed_error(msg)

data/lib/sequel/plugins/validate_associated.rb

@@ -43,6 +43,12 @@ module Sequel
       module InstanceMethods
         private
 
+        # Whether the associated object is valid. By default, the same as calling
+        # +valid?+ on the object, but exists so it can be overridden.
+        def associated_object_valid?(reflection, obj)
+          obj.valid?
+        end
+
         # Delay validating the associated object until validating the current object.
         def delay_validate_associated_object(reflection, obj)
           after_validation_hook{validate_associated_object(reflection, obj)}
@@ -62,7 +68,7 @@ module Sequel
             end
           end
 
-          unless obj.valid?
+          unless associated_object_valid?(reflection, obj)
             if ignore_key_errors
               # Ignore errors on the key column in the associated object. This column
               # will be set when saving to a presumably valid value using a column

data/lib/sequel/plugins/validate_associated_context.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The validate_associated_context plugin extends the validate_associated
+    # plugin to work with the validation_contexts plugin. It ensures associated
+    # objects are validated using the validation context of the current object.
+    #
+    # This plugin loads the validate_associated and validation_contexts plugins.
+    # The associated model must also use the validation_contexts plugin in order
+    # to access the validation context.
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validate_associated_context
+    #     many_to_one :artist
+    #
+    #     def validate
+    #       super
+    #       validate_associated_object(model.association_reflection(:artist), artist) if artist
+    #     end
+    #   end
+    #
+    #   class Artist < Sequel::Model
+    #     plugin :validation_contexts
+    #     def validate
+    #       super
+    #       errors.add(:name, 'not present') if name.nil? && validation_context == :publish
+    #     end
+    #   end
+    #
+    #   album = Album.new(artist: Artist.new)
+    #   album.valid?                               # => true
+    #   album.valid?(validation_context: :publish) # => false
+    module ValidateAssociatedContext
+      # Depend on the validate_associated and validation_contexts plugins.
+      def self.apply(model)
+        model.plugin :validate_associated
+        model.plugin :validation_contexts
+      end
+
+      module InstanceMethods
+        private
+
+        # Whether the associated object is valid, using the validation context
+        # of the current object.
+        def associated_object_valid?(reflection, obj)
+          obj.valid?(:validation_context=>validation_context)
+        end
+      end
+    end
+  end
+end