sequel 5.107.0 → 5.109.0

data/lib/sequel/plugins/lazy_attributes.rb

@@ -5,7 +5,7 @@ module Sequel
     # The lazy_attributes plugin allows users to easily set that some attributes
     # should not be loaded by default when loading model objects.  If the attribute
     # is needed after the instance has been retrieved, a database query is made to
-    # retreive the value of the attribute.
+    # retrieve the value of the attribute.
     #
     # This plugin depends on the tactical_eager_loading plugin, and allows you to
     # eagerly load lazy attributes for all objects retrieved with the current object.

data/lib/sequel/plugins/many_through_many.rb

@@ -243,7 +243,7 @@ module Sequel
         #            :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
         #            :join_type :: The join type to use for the join, defaults to :left_outer.
         #            :only_conditions :: Conditions to use for the join instead of the ones specified by the keys.
-        # opts :: The options for the associaion.  Takes the same options as many_to_many.
+        # opts :: The options for the association.  Takes the same options as many_to_many.
         def many_through_many(name, through, opts=OPTS, &block)
           associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
         end

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_array_associations.rb

@@ -534,9 +534,9 @@ module Sequel
         def many_to_pg_array_association_filter_expression(op, ref, obj)
           pk = ref.qualify(model.table_name, ref.primary_key)
           key = ref[:key]
-          # :nocov:
+          # simplecov:disable
           expr = case obj
-          # :nocov:
+          # simplecov:enable
           when Sequel::Model
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks.to_a]
@@ -556,9 +556,9 @@ module Sequel
         # Support filtering by pg_array_to_many associations using a subquery.
         def pg_array_to_many_association_filter_expression(op, ref, obj)
           key = ref.qualify(model.table_name, ref[:key_column])
-          # :nocov:
+          # simplecov:disable
           expr = case obj
-          # :nocov:
+          # simplecov:enable
           when Sequel::Model
             if pkv = obj.get_column_value(ref.primary_key_method)
               Sequel.pg_array_op(key).contains(Sequel.pg_array([pkv], ref.array_type))

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -261,9 +261,9 @@ module Sequel
             messages = model.pg_auto_constraint_validations_messages
 
             unless override
-              # :nocov:
+              # simplecov:disable
               case e
-              # :nocov:
+              # simplecov:enable
               when Sequel::NotNullConstraintViolation
                 if column = info[:column]
                   add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
@@ -297,7 +297,7 @@ module Sequel
               end
             end
           rescue
-            # If there is an error trying to conver the constraint violation
+            # If there is an error trying to convert the constraint violation
             # into a validation failure, it's best to just raise the constraint
             # violation.  This can make debugging the above block of code more
             # difficult.

data/lib/sequel/plugins/pg_eager_any_typed_array.rb

@@ -45,7 +45,7 @@ module Sequel
               key = key.column
             end
 
-            # :nocov:
+            # simplecov:disable
             # many_to_pg_array association type does not need changes, as it
             # already converts the values to a typed postgres array, it does
             # not call the code that uses :eager_loading_predicate_transform.
@@ -54,7 +54,7 @@ module Sequel
             # unless it is one of these types, but external association types
             # could potentially reach it.
             sch = case ref[:type]
-            # :nocov:
+            # simplecov:enable
             when :many_to_one, :one_to_one, :one_to_many, :pg_array_to_many
               ref.associated_class.db_schema
             when :many_to_many, :one_through_one

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/prepared_statements.rb

@@ -181,11 +181,11 @@ module Sequel
             # Disabling usage of prepared statements for insert_select on SQLite seems to be the
             # simplest way to workaround the problem.
             db.database_type != :sqlite
-          # :nocov:
+          # simplecov:disable
           when :delete, :refresh
             Sequel::Deprecation.deprecate("The :delete and :refresh prepared statement types", "There should be no need to check if these types are supported")
             false
-          # :nocov:
+          # simplecov:enable
           else
             raise Error, "unsupported type used: #{type.inspect}"
           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/serialization.rb

@@ -154,7 +154,7 @@ module Sequel
         
         private
 
-        # Add serializated attribute acessor methods to the serialization_module
+        # Add serializated attribute accessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
           include(@serialization_module ||= Sequel.set_temp_name(Module.new){"#{name}::@serialization_module"}) unless @serialization_module

data/lib/sequel/plugins/sharding.rb

@@ -6,7 +6,7 @@ module Sequel
     # in the following ways:
     #
     # * It automatically saves model instances back to the
-    #   shard they were retreived from.
+    #   shard they were retrieved from.
     # * It makes model associations use the same shard as the model object.
     # * It adds a slightly nicer API for creating model instances on
     #   specific shards.

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
@@ -194,7 +200,7 @@ module Sequel
         end
 
         # Copy the necessary attributes to the subclasses, and filter the
-        # subclass's dataset based on the sti_kep_map entry for the class.
+        # subclass's dataset based on the sti_key_map entry for the class.
         def inherited(subclass)
           super
           key = Array(sti_key_map[subclass]).dup
@@ -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/skip_saving_columns.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The skip_saving_columms plugin allows skipping specific columns when
+    # The skip_saving_columns plugin allows skipping specific columns when
     # saving.  By default, it skips columns that the database schema
     # indicates are generated columns:
     #
@@ -90,7 +90,7 @@ module Sequel
 
         # Skip the columns the model has marked to skip when updating
         # only changed columns.
-        def _save_update_changed_colums_hash
+        def _save_update_changed_columns_hash
           _save_removed_skipped_columns(super)
         end
 

data/lib/sequel/plugins/split_values.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The split_values plugin splits the values hash retreived from the
+    # The split_values plugin splits the values hash retrieved from the
     # database, and moves keys from the values hash that are not columns
     # in the model's dataset to a separate hash.  This makes it so the
     # values hash only stores columns from the model's dataset.

data/lib/sequel/plugins/sql_comments.rb

@@ -63,9 +63,9 @@ module Sequel
             super(*a, &block)
           end
         end
-        # :nocov:
+        # simplecov:disable
         mod.send(:ruby2_keywords, meth) if mod.respond_to?(:ruby2_keywords, true)
-        # :nocov:
+        # simplecov:enable
       end
 
       def self.apply(model)
@@ -101,9 +101,9 @@ module Sequel
               super(*a, &block)
             end
           end
-          # :nocov:
+          # simplecov:disable
           ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
-          # :nocov:
+          # simplecov:enable
         end
 
         private
@@ -133,9 +133,9 @@ module Sequel
               super(*a, &block)
             end
           end
-          # :nocov:
+          # simplecov:disable
           ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
-          # :nocov:
+          # simplecov:enable
         end
 
         private
@@ -163,9 +163,9 @@ module Sequel
               super(*a, &block)
             end
           end
-          # :nocov:
+          # simplecov:disable
           ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
-          # :nocov:
+          # simplecov:enable
         end
 
         private

data/lib/sequel/plugins/subclasses.rb

@@ -40,9 +40,9 @@ module Sequel
 
       # Initialize the subclasses instance variable for the model.
       def self.apply(model, &block)
-        # :nocov:
+        # simplecov:disable
         model.instance_variable_set(:@subclasses, [])  if NEED_SUBCLASSES
-        # :nocov:
+        # simplecov:enable
         model.instance_variable_set(:@on_subclass, block)
       end
 
@@ -51,13 +51,13 @@ module Sequel
         # class created.
         attr_reader :on_subclass
 
-        # :nocov:
+        # simplecov:disable
         if NEED_SUBCLASSES
           # All subclasses for the current model.  Does not
           # include the model itself.
           attr_reader :subclasses
         end
-        # :nocov:
+        # simplecov:enable
 
         # All descendent classes of this model.
         def descendants
@@ -85,9 +85,9 @@ module Sequel
         # in the subclass.
         def inherited(subclass)
           super
-          # :nocov:
+          # simplecov:disable
           Sequel.synchronize{subclasses << subclass} if NEED_SUBCLASSES
-          # :nocov:
+          # simplecov:enable
           on_subclass.call(subclass) if on_subclass
         end
       end

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.
-          # :nocov:
-          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
-          # :nocov:
+        # 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/tactical_eager_loading.rb

@@ -162,7 +162,7 @@ module Sequel
         end
 
         # Filter the objects used when tactical eager loading.
-        # By default, this removes frozen objects and objects that alreayd have the association loaded,
+        # By default, this removes frozen objects and objects that already have the association loaded,
         # as well as objects where the reflection for the association is not the same as the receiver's
         # reflection for the association.
         def _filter_tactical_eager_load_objects(opts)

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)
@@ -86,7 +86,7 @@ module Sequel
           # UncaughtThrowError was added in Ruby 2.2.  Older Ruby versions
           # used ArgumentError with "uncaught throw" at the start of the message
 
-          # :nocov:
+          # simplecov:disable
           def hook_failed_error(msg)
             e = super
             throw HookFailed, e
@@ -102,7 +102,7 @@ module Sequel
             raise e2 unless e2.message.start_with?('uncaught throw')
             e
           end
-          # :nocov:
+          # simplecov:enable
         end
       end
     end

data/lib/sequel/plugins/unused_associations.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-# :nocov:
+# simplecov:disable
 
 # This entire file is excluded from coverage testing.  This is because it
 # requires coverage testing to work, and if you've already loaded Sequel
@@ -67,7 +67,7 @@ module Sequel
     #
     # You can use the output of the +unused_associations+ method to determine
     # which associations are not used at all in your application, and can
-    # be eliminiated.
+    # be eliminated.
     #
     # You can also take that unused association data and pass it to the
     # +unused_association_options+ method, which will return an array of
@@ -131,7 +131,7 @@ module Sequel
     # = Automatic Usage of Unused Association Data
     #
     # Since it can be a pain to manually update all of your code
-    # to remove unused assocations or add options to prevent the
+    # to remove unused associations or add options to prevent the
     # definition of unused associations, the unused_associations
     # plugin comes with support to take previously saved unused
     # association data, and use it to not create unused associations,
@@ -265,7 +265,7 @@ module Sequel
       module ClassMethods
         # Only the data is copied to subclasses, to allow the :modify_associations
         # plugin option to affect them.  The :file and :coverage_file are not copied
-        # to subclasses, as users are expected ot call methods such as
+        # to subclasses, as users are expected to call methods such as
         # unused_associations only on the class that is loading the plugin.
         Plugins.inherited_instance_variables(self, :@unused_associations_data=>nil)
 
@@ -526,4 +526,4 @@ module Sequel
     end
   end
 end
-# :nocov:
+# simplecov:enable

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