sequel 5.45.0 → 5.77.0

data/lib/sequel/plugins/composition.rb

@@ -39,8 +39,8 @@ module Sequel
     # also be implemented as:
     #
     #   Album.composition :date,
-    #     :composer=>proc{Date.new(year, month, day) if year || month || day},
-    #     :decomposer=>(proc do
+    #     composer: proc{Date.new(year, month, day) if year || month || day},
+    #     decomposer: (proc do
     #       if d = compositions[:date]
     #         self.year = d.year
     #         self.month = d.month
@@ -174,6 +174,7 @@ module Sequel
           compositions
           super
           compositions.freeze
+          self
         end
 
         # For each composition, set the columns in the model class based

data/lib/sequel/plugins/concurrent_eager_loading.rb

@@ -50,10 +50,10 @@ module Sequel
     # support concurrent eager loading.  Taking this example from the
     # {Advanced Associations guide}[rdoc-ref:doc/advanced_associations.rdoc]
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     id_map = eo_opts[:id_map]
-    #     Artist.where(:id=>id_map.keys).all do |artist|
+    #     Artist.where(id: id_map.keys).all do |artist|
     #       if albums = id_map[artist.id]
     #         albums.each do |album|
     #           album.associations[:artist] = artist
@@ -74,12 +74,12 @@ module Sequel
     # the code that loads the objects, since that will prevent concurrent loading.
     # So after the changes, the custom eager loader would look like this:
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     end
     #     id_map = eo_opts[:id_map]
-    #     rows = Artist.where(:id=>id_map.keys).all
+    #     rows = Artist.where(id: id_map.keys).all
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       rows.each do |artist|
     #         if albums = id_map[artist.id]

data/lib/sequel/plugins/constraint_validations.rb

@@ -125,14 +125,15 @@ module Sequel
             ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
-            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
+            allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
             @constraint_validation_reflections = reflections
           end
         end
 
         # Given a specific database constraint validation metadata row hash, transform
         # it in an validation method call array suitable for splatting to send.
-        def constraint_validation_array(r, reflections)
+        def constraint_validation_array(r, reflections, allow_missing_columns=EMPTY_ARRAY)
           opts = {}
           opts[:message] = r[:message] if r[:message]
           opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
@@ -191,11 +192,13 @@ module Sequel
             reflection_opts[:argument] = arg
           end 
 
-          a << column
-          unless opts.empty?
-            a << opts
+          opts[:from] = :values
+          if column.is_a?(Symbol) && allow_missing_columns.include?(column)
+            opts[:allow_missing] = true
           end
 
+          a << column << opts
+
           if column.is_a?(Array) && column.length == 1
             column = column.first
           end

data/lib/sequel/plugins/defaults_setter.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require 'delegate'
+
 module Sequel
   module Plugins
     # The defaults_setter plugin makes the column getter methods return the default
@@ -106,6 +108,20 @@ module Sequel
             lambda{Date.today}
           when Sequel::CURRENT_TIMESTAMP
             lambda{dataset.current_datetime}
+          when Hash, Array
+            v = Marshal.dump(v).freeze
+            lambda{Marshal.load(v)}
+          when Delegator
+            # DelegateClass returns an anonymous case, which cannot be marshalled, so marshal the
+            # underlying object and create a new instance of the class with the unmarshalled object.
+            klass = v.class
+            case o = v.__getobj__
+            when Hash, Array
+              v = Marshal.dump(o).freeze
+              lambda{klass.new(Marshal.load(v))}
+            else
+              v
+            end
           else
             v
           end

data/lib/sequel/plugins/dirty.rb

@@ -37,7 +37,7 @@ module Sequel
     #
     # It also saves the previously changed values after an update:
     #
-    #   artist.update(:name=>'Bar')
+    #   artist.update(name: 'Bar')
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
     #

data/lib/sequel/plugins/enum.rb

@@ -0,0 +1,124 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The enum plugin allows for easily adding methods to modify the value of
+    # a column.  It allows treating the column itself as an enum, returning a
+    # symbol for the related enum value.  It also allows for setting up dataset
+    # methods to easily find records having or not having each enum value.
+    #
+    # After loading the plugin, you can call the +enum+ method to define the
+    # methods.  The +enum+ method accepts a symbol for the underlying
+    # database column, and a hash with symbol keys for the enum values.
+    # For example, the following call:
+    #
+    #   Album.enum :status_id, good: 1, bad: 2
+    #
+    # Will define the following instance methods:
+    #
+    # Album#good! :: Change +status_id+ to +1+ (does not save the receiver)
+    # Album#bad! :: Change +status_id+ to +2+ (does not save the receiver)
+    # Album#good? :: Return whether +status_id+ is +1+
+    # Album#bad? :: Return whether +status_id+ is +2+
+    #
+    # It will override the following instance methods:
+    #
+    # Album#status_id :: Return +:good+/+:bad+ instead of +1+/+2+ (other values returned as-is)
+    # Album#status_id= :: Allow calling with +:good+/+:bad+ to set +status_id+ to +1+/+2+ (other values,
+    #                     such as <tt>'good'</tt>/<tt>'bad'</tt> set as-is)
+    #
+    # If will define the following dataset methods:
+    #
+    # Album.dataset.good :: Return a dataset filtered to rows where +status_id+ is +1+
+    # Album.dataset.not_good :: Return a dataset filtered to rows where +status_id+ is not +1+
+    # Album.dataset.bad:: Return a dataset filtered to rows where +status_id+ is +2+
+    # Album.dataset.not_bad:: Return a dataset filtered to rows where +status_id+ is not +2+
+    #
+    # When calling +enum+, you can also provide the following options:
+    #
+    # :prefix :: Use a prefix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the prefix.
+    #            For example, with <tt>prefix: 'status'</tt>, the instance methods defined above would be +status_good?+, +status_bad?+,
+    #            +status_good!+, and +status_bad!+, and the dataset methods defined would be +status_good+, +status_not_good+, +status_bad+,
+    #            and +status_not_bad+.
+    # :suffix :: Use a suffix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the suffix.
+    #            For example, with <tt>suffix: 'status'</tt>, the instance methods defined above would be +good_status?+, +bad_status?+,
+    #            +good_status!+, and +bad_status!+, and the dataset methods defined would be +good_status+, +not_good_status+, +bad_status+,
+    #            and +not_bad_status+.
+    # :override_accessors :: Set to +false+ to not override the column accessor methods.
+    # :dataset_methods :: Set to +false+ to not define dataset methods.
+    #
+    # Note that this does not use a true enum column in the database.  If you are
+    # looking for enum support in the database, and your are using PostgreSQL,
+    # Sequel supports that via the pg_enum Database extension.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses handle enums
+    #   Sequel::Model.plugin :enum
+    #
+    #   # Make the Album class handle enums
+    #   Album.plugin :enum
+    module Enum
+      module ClassMethods
+        # Define instance and dataset methods in this class to treat column
+        # as a enum.  See Enum documentation for usage.
+        def enum(column, values, opts=OPTS)
+          raise Sequel::Error, "enum column must be a symbol" unless column.is_a?(Symbol)
+          raise Sequel::Error, "enum values must be provided as a hash with symbol keys" unless values.is_a?(Hash) && values.all?{|k,| k.is_a?(Symbol)}
+
+          if prefix = opts[:prefix]
+            prefix = column if prefix == true
+            prefix = "#{prefix}_"
+          end
+
+          if suffix = opts[:suffix]
+            suffix = column if suffix == true
+            suffix = "_#{suffix}"
+          end
+          
+          values = Hash[values].freeze
+          inverted = values.invert.freeze
+
+          unless @enum_methods
+            @enum_methods = Module.new
+            include @enum_methods
+          end
+
+          @enum_methods.module_eval do
+            unless opts[:override_accessors] == false
+              define_method(column) do
+                v = super()
+                inverted.fetch(v, v)
+              end
+
+              define_method(:"#{column}=") do |v|
+                super(values.fetch(v, v))
+              end
+            end
+
+            values.each do |key, value|
+              define_method(:"#{prefix}#{key}#{suffix}!") do
+                self[column] = value
+                nil
+              end
+
+              define_method(:"#{prefix}#{key}#{suffix}?") do
+                self[column] == value
+              end
+            end
+          end
+
+          unless opts[:dataset_methods] == false
+            dataset_module do
+              values.each do |key, value|
+                cond = Sequel[column=>value]
+                where :"#{prefix}#{key}#{suffix}", cond
+                where :"#{prefix}not_#{key}#{suffix}", ~cond
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/finder.rb

@@ -97,7 +97,9 @@ module Sequel
         #   Artist.first_by_name(nil)
         #   # WHERE (name IS NULL)
         #
-        # See Dataset::PlaceholderLiteralizer for additional caveats.
+        # See Dataset::PlaceholderLiteralizer for additional caveats. Note that if the model's
+        # dataset does not support placeholder literalizers, you will not be able to use this
+        # method.
         def finder(meth=OPTS, opts=OPTS, &block)
           if block
             raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
@@ -149,7 +151,7 @@ module Sequel
                 ds
               end
 
-              Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+              model.dataset.placeholder_literalizer_class.loader(model, &block) 
             end
           end
 

data/lib/sequel/plugins/insert_conflict.rb

@@ -22,6 +22,10 @@ module Sequel
     # for that album.  See the PostgreSQL and SQLite adapter documention for
     # the options you can pass to the insert_conflict method.
     #
+    # You should not attempt to use this plugin to ignore conflicts when
+    # inserting, you should only use it to turn insert conflicts into updates.
+    # Any usage to ignore conflicts is not recommended or supported.
+    #
     # Usage:
     #
     #   # Make all model subclasses support insert_conflict

data/lib/sequel/plugins/instance_specific_default.rb

@@ -29,7 +29,7 @@ module Sequel
     #   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
+    # +last_track+ 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:

data/lib/sequel/plugins/json_serializer.rb

@@ -365,7 +365,7 @@ module Sequel
             h = {root => h}
           end
 
-          h = yield h if block_given?
+          h = yield h if defined?(yield)
           Sequel.object_to_json(h, *a)
         end
 
@@ -441,7 +441,7 @@ module Sequel
           end
 
           res = {collection_root => res} if collection_root
-          res = yield res if block_given?
+          res = yield res if defined?(yield)
 
           Sequel.object_to_json(res, *a)
         end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -52,7 +52,9 @@ module Sequel
           unless select = dataset.opts[:select]
             select = dataset.columns.map{|c| Sequel.qualify(dataset.first_source, c)}
           end
+          db_schema = @db_schema
           set_dataset(dataset.select(*select.reject{|c| attrs.include?(dataset.send(:_hash_key_symbol, c))}))
+          @db_schema = db_schema
           attrs.each{|a| define_lazy_attribute_getter(a)}
         end
         
@@ -71,6 +73,7 @@ module Sequel
                 super()
               end
             end
+            alias_method(a, a)
           end
         end
       end

data/lib/sequel/plugins/list.rb

@@ -33,7 +33,9 @@ module Sequel
     # You can provide a <tt>:scope</tt> option to scope the list.  This option
     # can be a symbol or array of symbols specifying column name(s), or a proc
     # that accepts a model instance and returns a dataset representing the list
-    # the object is in.
+    # the object is in.  You will need to provide a <tt>:scope</tt> option if
+    # the model's dataset uses a subquery (such as when using the class_table_inheritance
+    # plugin).
     # 
     # For example, if each item has a +user_id+ field, and you want every user
     # to have their own list:
@@ -183,10 +185,13 @@ module Sequel
         end
 
         # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
+        # position field already has a value. If the list is empty, the position will
+        # be set to the model's +top_of_list+ value.
         def before_validation
           unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
+            current_max = list_dataset.max(position_field)
+            value = current_max.nil? ? model.top_of_list : current_max.to_i + 1
+            set_column_value("#{position_field}=", value)
           end
           super
         end

data/lib/sequel/plugins/many_through_many.rb

@@ -123,16 +123,25 @@ module Sequel
           nil
         end
 
+        # Whether a separate query should be used for each join table.
+        def separate_query_per_table?
+          self[:separate_query_per_table]
+        end
+
         private
 
         def _associated_dataset
           ds = associated_class
-          (reverse_edges + [final_reverse_edge]).each do |t|
-            h = {:qualify=>:deep}
-            if t[:alias] != t[:table]
-              h[:table_alias] = t[:alias]
+          if separate_query_per_table?
+            ds = ds.dataset
+          else
+            (reverse_edges + [final_reverse_edge]).each do |t|
+              h = {:qualify=>:deep}
+              if t[:alias] != t[:table]
+                h[:table_alias] = t[:alias]
+              end
+              ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
             end
-            ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
           end
           ds
         end
@@ -208,6 +217,7 @@ module Sequel
         #            :right (last array element) :: The key joining the table to the next table. Can use an
         #                                           array of symbols for a composite key association.
         #            If a hash is provided, the following keys are respected when using eager_graph:
+        #            :db :: The Database containing the table.  This changes lookup to use a separate query for each join table.
         #            :block :: A proc to use as the block argument to join.
         #            :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.
@@ -233,32 +243,121 @@ module Sequel
             opts[:after_load].unshift(:array_uniq!)
           end
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
-          opts[:through] = opts[:through].map do |e|
+          separate_query_per_table = false
+          through = opts[:through] = opts[:through].map do |e|
             case e
             when Array
               raise(Error, "array elements of the through option/argument for many_through_many associations must have at least three elements") unless e.length == 3
               {:table=>e[0], :left=>e[1], :right=>e[2]}
             when Hash
               raise(Error, "hash elements of the through option/argument for many_through_many associations must contain :table, :left, and :right keys") unless e[:table] && e[:left] && e[:right]
+              separate_query_per_table = true if e[:db]
               e
             else
               raise(Error, "the through option/argument for many_through_many associations must be an enumerable of arrays or hashes")
             end
           end
+          opts[:separate_query_per_table] = separate_query_per_table
 
           left_key = opts[:left_key] = opts[:through].first[:left]
           opts[:left_keys] = Array(left_key)
-          opts[:uses_left_composite_keys] = left_key.is_a?(Array)
+          uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
           raise(Error, "no primary key specified for #{inspect}") unless left_pk
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
-          opts[:dataset] ||= opts.association_dataset_proc
 
           opts[:left_key_alias] ||= opts.default_associated_key_alias
-          opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          if separate_query_per_table
+            opts[:use_placeholder_loader] = false
+            opts[:allow_eager_graph] = false
+            opts[:allow_filtering_by] = false
+            opts[:eager_limit_strategy] = nil
+
+            opts[:dataset] ||= proc do |r|
+              def_db = r.associated_class.db
+              vals = uses_lcks ? [lpkcs.map{|k| get_column_value(k)}] : get_column_value(left_pk)
+
+              has_results = through.each do |edge|
+                ds = (edge[:db] || def_db).from(edge[:table]).where(edge[:left]=>vals)
+                ds = ds.where(edge[:conditions]) if edge[:conditions]
+                right = edge[:right]
+                vals = ds.select_map(right)
+                if right.is_a?(Array)
+                  vals.delete_if{|v| v.any?(&:nil?)}
+                else
+                  vals.delete(nil)
+                end
+                break if vals.empty?
+              end
+
+              ds = r.associated_dataset.where(opts.right_primary_key=>vals)
+              ds = ds.clone(:no_results=>true) unless has_results
+              ds
+            end
+            opts[:eager_loader] ||= proc do |eo|
+              h = eo[:id_map]
+              assign_singular = opts.assign_singular?
+              uses_rcks = opts.right_primary_key.is_a?(Array)
+              rpk = uses_rcks ? opts.right_primary_keys : opts.right_primary_key
+              name = opts[:name]
+              def_db = opts.associated_class.db
+              join_map = h
+
+              run_query = through.each do |edge|
+                ds = (edge[:db] || def_db).from(edge[:table])
+                ds = ds.where(edge[:conditions]) if edge[:conditions]
+                left = edge[:left]
+                right = edge[:right]
+                prev_map = join_map
+                join_map = ds.where(left=>join_map.keys).select_hash_groups(right, left)
+                if right.is_a?(Array)
+                  join_map.delete_if{|v,| v.any?(&:nil?)}
+                else
+                  join_map.delete(nil)
+                end
+                break if join_map.empty?
+                join_map.each_value do |vs|
+                  vs.replace(vs.flat_map{|v| prev_map[v]})
+                  vs.uniq!
+                end
+              end
+
+              eo = Hash[eo]
+
+              if run_query
+                eo[:loader] = false
+                eo[:right_keys] = join_map.keys
+              else
+                eo[:no_results] = true
+              end
+
+              opts[:model].eager_load_results(opts, eo) do |assoc_record|
+                rpkv = if uses_rcks
+                  assoc_record.values.values_at(*rpk)
+                else
+                  assoc_record.values[rpk]
+                end
+
+                objects = join_map[rpkv]
+
+                if assign_singular
+                  objects.each do |object|
+                    object.associations[name] ||= assoc_record
+                  end
+                else
+                  objects.each do |object|
+                    object.associations[name].push(assoc_record)
+                  end
+                end
+              end
+            end
+          else
+            opts[:dataset] ||= opts.association_dataset_proc
+            opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          end
 
           join_type = opts[:graph_join_type]
           select = opts[:graph_select]
@@ -286,7 +385,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class.dataset, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
+              ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           end
         end

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -26,57 +26,27 @@ module Sequel
     module MssqlOptimisticLocking
       # Load the instance_filters plugin into the model.
       def self.apply(model, opts=OPTS)
-        model.plugin :instance_filters
+        model.plugin(:optimistic_locking_base)
       end
 
-      # Set the lock_column to the :lock_column option (default: :timestamp)
+      # Set the lock column
       def self.configure(model, opts=OPTS)
-        model.lock_column = opts[:lock_column] || :timestamp
+        model.lock_column = opts[:lock_column] || model.lock_column || :timestamp
       end
-
-      module ClassMethods
-        # The timestamp/rowversion column containing the version for the current row.
-        attr_accessor :lock_column
-
-        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
-      end
-
+      
       module InstanceMethods
-        # Add the lock column instance filter to the object before destroying it.
-        def before_destroy
-          lock_column_instance_filter
-          super
-        end
-        
-        # Add the lock column instance filter to the object before updating it.
-        def before_update
-          lock_column_instance_filter
-          super
-        end
-        
         private
         
-        # Add the lock column instance filter to the object.
-        def lock_column_instance_filter
-          lc = model.lock_column
-          instance_filter(lc=>Sequel.blob(get_column_value(lc)))
-        end
-
-        # Clear the instance filters when refreshing, so that attempting to
-        # refresh after a failed save removes the previous lock column filter
-        # (the new one will be added before updating).
-        def _refresh(ds)
-          clear_instance_filters
-          super
+        # Make the instance filter value a blob.
+        def lock_column_instance_filter_value
+          Sequel.blob(super)
         end
 
         # Remove the lock column from the columns to update.
         # SQL Server automatically updates the lock column value, and does not like
         # it to be assigned.
         def _save_update_all_columns_hash
-          v = @values.dup
-          cc = changed_columns
-          Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
+          v = super
           v.delete(model.lock_column)
           v
         end

data/lib/sequel/plugins/nested_attributes.rb

@@ -33,7 +33,7 @@ module Sequel
     # objects.  You just need to make sure that the primary key field is filled in for the
     # associated object:
     #
-    #   a.update(:albums_attributes => [{id: 1, name: 'T'}])
+    #   a.update(albums_attributes: [{id: 1, name: 'T'}])
     #
     # Since the primary key field is filled in, the plugin will update the album with id 1 instead
     # of creating a new album.
@@ -42,14 +42,14 @@ module Sequel
     # entry to the hash, and also pass the :destroy option when calling +nested_attributes+:
     #
     #   Artist.nested_attributes :albums, destroy: true
-    #   a.update(:albums_attributes => [{id: 1, _delete: true}])
+    #   a.update(albums_attributes: [{id: 1, _delete: true}])
     #
     # This will delete the related associated object from the database.  If you want to leave the
     # associated object in the database, but just remove it from the association, add a _remove
     # entry in the hash, and also pass the :remove option when calling +nested_attributes+:
     #
     #   Artist.nested_attributes :albums, remove: true
-    #   a.update(:albums_attributes => [{id: 1, _remove: true}])
+    #   a.update(albums_attributes: [{id: 1, _remove: true}])
     #
     # The above example was for a one_to_many association, but the plugin also works similarly
     # for other association types.  For one_to_one and many_to_one associations, you need to
@@ -84,7 +84,7 @@ module Sequel
     # 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')
+    #   a.set_nested_attributes(:albums, params['artist'], fields: %w'name')
     module NestedAttributes
       # Depend on the validate_associated plugin.
       def self.apply(model)