sequel 5.8.0 → 5.38.0

data/lib/sequel/plugins/hook_class_methods.rb

@@ -59,7 +59,14 @@ module Sequel
     
         # Yield every block related to the given hook.
         def hook_blocks(hook)
-          @hooks[hook].each{|k,v| yield v}
+          # SEQUEL6: Remove
+          Sequel::Deprecation.deprecate("The hook_blocks class method in the hook_class_methods plugin is deprecated and will be removed in Sequel 6.")
+          @hooks[hook].each{|_,v,_| yield v}
+        end
+
+        # Yield every method related to the given hook.
+        def hook_methods_for(hook)
+          @hooks[hook].each{|_,_,m| yield m}
         end
 
         Plugins.inherited_instance_variables(self, :@hooks=>:hash_dup)
@@ -75,23 +82,28 @@ module Sequel
             # Allow calling private hook methods
             block = proc {send(tag)}
           end
+
           h = @hooks[hook]
+
           if tag && (old = h.find{|x| x[0] == tag})
             old[1] = block
+            Plugins.def_sequel_method(self, old[2], 0, &block)
           else
+            meth = Plugins.def_sequel_method(self, "validation_class_methods_#{hook}", 0, &block)
             if hook.to_s =~ /^before/
-              h.unshift([tag,block])
+              h.unshift([tag, block, meth])
             else
-              h << [tag, block]
+              h << [tag, block, meth]
             end
           end
         end
       end
 
       module InstanceMethods
-        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| instance_exec(&b)}; super end", __FILE__, __LINE__)}
+        # hook methods are private
+        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_methods_for(:#{h}){|m| send(m)}; super end", __FILE__, __LINE__)}
 
-        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_exec(&b)}; end", __FILE__, __LINE__)}
+        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_methods_for(:#{h}){|m| send(m)}; end", __FILE__, __LINE__)}
       end
     end
   end

data/lib/sequel/plugins/insert_conflict.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The insert_conflict plugin allows handling conflicts due to unique
+    # constraints when saving new model instance, using the INSERT ON CONFLICT
+    # support in PostgreSQL 9.5+ and SQLite 3.24.0+. Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :insert_conflict
+    #   end
+    #
+    #   Album.new(name: 'Foo', copies_sold: 1000).
+    #     insert_conflict(
+    #       target: :name,
+    #       update: {copies_sold: Sequel[:excluded][:b]}
+    #     ).
+    #     save
+    #
+    # This example will try to insert the album, but if there is an existing
+    # album with the name 'Foo', this will update the copies_sold attribute
+    # for that album.  See the PostgreSQL and SQLite adapter documention for
+    # the options you can pass to the insert_conflict method.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support insert_conflict
+    #   Sequel::Model.plugin :insert_conflict
+    #
+    #   # Make the Album class support insert_conflict
+    #   Album.plugin :insert_conflict
+    module InsertConflict
+      def self.configure(model)
+        model.instance_exec do
+          if @dataset && !@dataset.respond_to?(:insert_conflict)
+            raise Error, "#{self}'s dataset does not support insert_conflict"
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set the insert_conflict options to pass to the dataset when inserting. 
+        def insert_conflict(opts=OPTS)
+          raise Error, "Model#insert_conflict is only supported on new model instances" unless new?
+          @insert_conflict_opts = opts
+          self
+        end
+
+        private
+
+        # Set the dataset used for inserting to use INSERT ON CONFLICT
+        # Model#insert_conflict has been called on the instance previously.
+        def _insert_dataset
+          ds = super
+
+          if @insert_conflict_opts
+            ds = ds.insert_conflict(@insert_conflict_opts)
+          end
+
+          ds
+        end
+
+        # Disable the use of prepared insert statements, as they are not compatible
+        # with this plugin.
+        def use_prepared_statements_for?(type)
+          return false if type == :insert || type == :insert_select
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/instance_specific_default.rb

@@ -0,0 +1,113 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The instance_specific_default plugin exists to make it easier to use a
+    # global :instance_specific association option, or to warn or raise when Sequel
+    # has to guess which value to use :instance_specific option (Sequel defaults to
+    # guessing true as that is the conservative setting).  It is helpful to
+    # use this plugin, particularly with the :warn or :raise settings, to determine
+    # which associations should have :instance_specific set.  Setting the
+    # :instance_specific to false for associations that are not instance specific
+    # can improve performance.
+    #
+    # Associations are instance-specific if their block calls
+    # a model instance method, or where the value of the block varies
+    # based on runtime state, and the variance is outside of a delayed evaluation.
+    # For example, with the following three associations:
+    #
+    #   Album.one_to_one :first_track, class: :Track do |ds|
+    #     ds.where(number: 1)
+    #   end
+    #
+    #   Album.one_to_one :last_track, class: :Track do |ds|
+    #     ds.where(number: num_tracks)
+    #   end
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track do |ds|
+    #     ds.where{date_updated > Date.today - 10}
+    #   end
+    #
+    # +first_track+ is not instance specific, but +last_track+ and +recent_tracks+ are.
+    # +last_trac+ is because the +num_tracks+ call in the block is calling
+    # <tt>Album#num_tracks</tt>.  +recent_tracks+ is because the value will change over
+    # time. This plugin allows you to find these cases, and set the :instance_specific
+    # option appropriately for them:
+    #
+    #   Album.one_to_one :first_track, class: :Track, instance_specific: false do |ds|
+    #     ds.where(number: 1)
+    #   end
+    #
+    #   Album.one_to_one :last_track, class: :Track, instance_specific: true do |ds|
+    #     ds.where(number: num_tracks)
+    #   end
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track, instance_specific: true do |ds|
+    #     ds.where{date_updated > Date.today - 10}
+    #   end
+    #
+    # For the +recent_tracks+ association, instead of marking it instance_specific, you
+    # could also use a delayed evaluation, since it doesn't actually contain
+    # instance-specific code:
+    #
+    #   Album.one_to_many :recent_tracks, class: :Track, instance_specific: false do |ds|
+    #     ds.where{date_updated > Sequel.delay{Date.today - 10}}
+    #   end
+    #
+    # Possible arguments to provide when loading the plugin:
+    #
+    # true :: Set the :instance_specific option to true
+    # false :: Set the :instance_specific option to false
+    # :default :: Call super to set the :instance_specific option
+    # :warn :: Emit a warning before calling super to set the :instance_specific option
+    # :raise :: Raise a Sequel::Error if an :instance_specific option is not provided and
+    #           an association could be instance-specific.
+    #
+    # Note that this plugin only affects associations which could be instance
+    # specific (those with blocks), where the :instance_specific option was not
+    # specified when the association was created.
+    #
+    # Usage:
+    #
+    #   # Set how to handle associations that could be instance specific
+    #   # but did not specify an :instance_specific option, for all subclasses
+    #   # (set before creating subclasses).
+    #   Sequel::Model.plugin :instance_specific_default, :warn
+    #
+    #   # Set how to handle associations that could be instance specific
+    #   # but did not specify an :instance_specific option, for the Album class
+    #   Album.plugin :instance_specific_default, :warn
+    module InstanceSpecificDefault
+      # Set how to handle associations that could be instance specific but did
+      # not specify an :instance_specific value.
+      def self.configure(model, default)
+        model.instance_variable_set(:@instance_specific_default, default)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@instance_specific_default=>nil)
+
+        private
+
+        # Return the appropriate :instance_specific value, or warn or raise if
+        # configured.
+        def _association_instance_specific_default(name)
+          case @instance_specific_default
+          when true, false
+            return @instance_specific_default
+          when :default
+            # nothing
+          when :warn
+            warn("possibly instance-specific association without :instance_specific option (class: #{self}, association: #{name})", :uplevel => 3)
+          when :raise
+            raise Sequel::Error, "possibly instance-specific association without :instance_specific option (class: #{self}, association: #{name})"
+          else
+            raise Sequel::Error, "invalid value passed to instance_specific_default plugin: #{@instance_specific_default.inspect}"
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/inverted_subsets.rb

@@ -29,8 +29,8 @@ module Sequel
     #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
     #
     module InvertedSubsets
-      def self.apply(mod, &block)
-        mod.instance_exec do
+      def self.apply(model, &block)
+        model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
             include DatasetModuleMethods
             if block

data/lib/sequel/plugins/json_serializer.rb

@@ -106,17 +106,13 @@ module Sequel
     # and breaks some aspects of the json_serializer plugin.  You can undo the damage
     # done by active_support/json by doing:
     #
-    #   class Array
-    #     def to_json(options = {})
-    #       JSON.generate(self)
-    #     end
-    #   end
-    #
-    #   class Hash
+    #   module ActiveSupportBrokenJSONFix
     #     def to_json(options = {})
     #       JSON.generate(self)
     #     end
     #   end
+    #   Array.send(:prepend, ActiveSupportBrokenJSONFix)
+    #   Hash.send(:prepend, ActiveSupportBrokenJSONFix)
     #
     # Note that this will probably cause active_support/json to no longer work
     # correctly in some cases.
@@ -279,7 +275,7 @@ module Sequel
         #   obj.json_serializer_opts(only: :name)
         #   [obj].to_json # => '[{"name":"..."}]'
         def json_serializer_opts(opts=OPTS)
-          @json_serializer_opts = Hash[@json_serializer_opts||OPTS].merge!(opts)
+          @json_serializer_opts = (@json_serializer_opts||OPTS).merge(opts)
         end
 
         # Return a string in JSON format.  Accepts the following
@@ -301,9 +297,9 @@ module Sequel
         #          use an underscored version of the model's name.
         def to_json(*a)
           opts = model.json_serializer_opts
-          opts = Hash[opts].merge!(@json_serializer_opts) if @json_serializer_opts
+          opts = opts.merge(@json_serializer_opts) if @json_serializer_opts
           if (arg_opts = a.first).is_a?(Hash)
-            opts = Hash[opts].merge!(arg_opts)
+            opts = opts.merge(arg_opts)
             a = []
           end
 
@@ -369,6 +365,13 @@ module Sequel
       end
 
       module DatasetMethods
+        # Store default options used when calling to_json on this dataset.
+        # These options take precedence over the class level options,
+        # and can be overridden by passing options directly to to_json.
+        def json_serializer_opts(opts=OPTS)
+          clone(:json_serializer_opts=>opts)
+        end
+
         # Return a JSON string representing an array of all objects in
         # this dataset.  Takes the same options as the instance
         # method, and passes them to every instance.  Additionally,
@@ -386,11 +389,15 @@ module Sequel
         #          object.  If set to a string, wraps the collection in
         #          a root object using the string as the key.  
         def to_json(*a)
-          if opts = a.first.is_a?(Hash)
-            opts = model.json_serializer_opts.merge(a.first)
+          opts = model.json_serializer_opts
+
+          if ds_opts = @opts[:json_serializer_opts]
+            opts = opts.merge(ds_opts)
+          end
+
+          if (arg = a.first).is_a?(Hash)
+            opts = opts.merge(arg)
             a = []
-          else
-            opts = model.json_serializer_opts
           end
 
           case collection_root = opts[:root]

data/lib/sequel/plugins/lazy_attributes.rb

@@ -98,7 +98,7 @@ module Sequel
           end
 
           if retrieved_with
-            raise(Error, "Invalid primary key column for #{model}: #{pkc.inspect}") unless primary_key = model.primary_key
+            primary_key = model.primary_key
             composite_pk = true if primary_key.is_a?(Array)
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}

data/lib/sequel/plugins/list.rb

@@ -45,19 +45,26 @@ module Sequel
     # race conditions, and is not safe when concurrent modifications are made
     # to the same list.
     #
-    # Additionally, note that unlike ruby arrays, the list plugin assumes that the
-    # first entry in the list has position 1, not position 0.
+    # Note that by default, unlike ruby arrays, the list plugin assumes the first
+    # entry in the list has position 1, not position 0.
+    #
+    # You can change this by providing an integer <tt>:top</tt> option:
+    #
+    #   Item.plugin :list, top: 0
     #
     # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
     module List
-      # Set the +position_field+ and +scope_proc+ attributes for the model,
-      # using the <tt>:field</tt> and <tt>:scope</tt> options, respectively.
+      # Set the +position_field+, +scope_proc+ and +top_of_list+ attributes for the model,
+      # using the <tt>:field</tt>, <tt>:scope</tt>, and <tt>:top</tt> options, respectively.
       # The <tt>:scope</tt> option can be a symbol, array of symbols, or a proc that
       # accepts a model instance and returns a dataset representing the list.
       # Also, modify the model dataset's order to order by the position and scope fields.
       def self.configure(model, opts = OPTS)
         model.position_field = opts[:field] || :position
         model.dataset = model.dataset.order_prepend(model.position_field)
+        model.instance_exec do
+          @top_of_list = opts[:top] || 1
+        end
         
         model.scope_proc = case scope = opts[:scope]
         when Symbol
@@ -80,7 +87,10 @@ module Sequel
         # proc should accept an instance and return a dataset representing the list.
         attr_accessor :scope_proc
 
-        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil)
+        # An Integer to use as the position of the top of the list. Defaults to 1.
+        attr_reader :top_of_list
+
+        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil, :@top_of_list=>nil)
       end
 
       module InstanceMethods
@@ -114,15 +124,17 @@ module Sequel
           move_to(position_value + n)
         end
 
-        # Move this instance to the given place in the list.  Raises an
-        # exception if target is less than 1 or greater than the last position in the list.
+        # Move this instance to the given place in the list.  If lp is not
+        # given or greater than the last list position, uses the last list
+        # position.  If lp is less than the top list position, uses the
+        # top list position.
         def move_to(target, lp = nil)
           current = position_value
           if target != current
             checked_transaction do
               ds = list_dataset
               op, ds = if target < current
-                target = 1 if target < 1
+                target = model.top_of_list if target < model.top_of_list
                 [:+, ds.where(position_field=>target...current)]
               else
                 lp ||= last_position
@@ -142,9 +154,9 @@ module Sequel
           move_to(lp, lp)
         end
 
-        # Move this instance to the top (first position, position 1) of the list.
+        # Move this instance to the top (first position, usually position 1) of the list.
         def move_to_top
-          move_to(1)
+          move_to(model.top_of_list)
         end
 
         # Move this instance the given number of places up in the list, or 1 place

data/lib/sequel/plugins/many_through_many.rb

@@ -144,7 +144,7 @@ module Sequel
             table_alias = e[:table]
             if aliases.include?(table_alias)
               i = 0
-              table_alias = loop do
+              table_alias = while true
                 ta = :"#{table_alias}_#{i}"
                 break ta unless aliases.include?(ta)
                 i += 1

data/lib/sequel/plugins/nested_attributes.rb

@@ -70,10 +70,21 @@ module Sequel
     #
     # Then you can do:
     #
-    #   artist.update_fields(params['artist'], %w'name albums_artists')
+    #   artist.update_fields(params['artist'], %w'name albums_attributes')
+    #
+    # Note that Rails 5+ does not use a Hash for submitted parameters, and therefore
+    # the above will not work.  With Rails 5+, you have to use:
+    #
+    #   artist.update_fields(params.to_unsafe_h['artist'], %w'name albums_attributes')
     #
     # To save changes to the artist, create the first album and associate it to the artist,
     # and update the other existing associated album.
+    #
+    # You can pass options for individual nested attributes, which will override the default
+    # nested attributes options for that association.  This is useful for per-call filtering
+    # of the allowed fields:
+    #
+    #   a.set_nested_attributes(:albums, params['artist'], :fields=>%w'name')
     module NestedAttributes
       # Depend on the validate_associated plugin.
       def self.apply(model)
@@ -102,6 +113,10 @@ module Sequel
         #               value, the attribute hash is ignored.
         # :remove :: Allow disassociation of nested records (can remove the associated
         #            object from the parent object, but not destroy the associated object).
+        # :require_modification :: Whether to require modification of nested objects when
+        #                          updating or deleting them (checking that a single row was
+        #                          updated).  By default, uses the default require_modification
+        #                          setting for the nested object.
         # :transform :: A proc to transform attribute hashes before they are
         #               passed to associated object. Takes two arguments, the parent object and
         #               the attribute hash. Uses the return value as the new attribute hash.
@@ -114,10 +129,10 @@ module Sequel
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
           include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
-          opts = associations.last.is_a?(Hash) ? associations.pop : {}
+          opts = associations.last.is_a?(Hash) ? associations.pop : OPTS
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
-            r[:nested_attributes] = opts
+            r[:nested_attributes] = opts.dup
             r[:nested_attributes][:unmatched_pk] ||= :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
@@ -144,7 +159,7 @@ module Sequel
         def set_nested_attributes(assoc, obj, opts=OPTS)
           raise(Error, "no association named #{assoc} for #{model.inspect}") unless ref = model.association_reflection(assoc)
           raise(Error, "nested attributes are not enabled for association #{assoc} for #{model.inspect}") unless meta = ref[:nested_attributes]
-          meta = Hash[meta].merge!(opts)
+          meta = meta.merge(opts)
           meta[:reflection] = ref
           if ref.returns_array?
             nested_attributes_list_setter(meta, obj)
@@ -176,6 +191,7 @@ module Sequel
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
             public_send(reflection[:name]) << obj
+            obj.skip_validation_on_next_save!
             after_save_hook{public_send(reflection[:add_method], obj)}
           else
             associations[reflection[:name]] = obj
@@ -190,7 +206,10 @@ module Sequel
             if reflection[:type] == :many_to_one 
               before_save_hook{public_send(reflection[:setter_method], obj.save(:validate=>false))}
             else
-              after_save_hook{public_send(reflection[:setter_method], obj)}
+              after_save_hook do
+                obj.skip_validation_on_next_save!
+                public_send(reflection[:setter_method], obj)
+              end
             end
           end
           add_reciprocal_object(reflection, obj)
@@ -267,6 +286,9 @@ module Sequel
             obj = Array(public_send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
+            unless (require_modification = meta[:require_modification]).nil?
+              obj.require_modification = require_modification
+            end
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
             if meta[:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
               nested_attributes_remove(meta, obj, :destroy=>true)