sequel 5.31.0 → 5.36.0

data/lib/sequel/model/base.rb

@@ -460,47 +460,6 @@ module Sequel
         super
       end
 
-      # If possible, set the dataset for the model subclass as soon as it
-      # is created.  Also, make sure the inherited class instance variables
-      # are copied into the subclass.
-      #
-      # Sequel queries the database to get schema information as soon as
-      # a model class is created:
-      #
-      #   class Artist < Sequel::Model # Causes schema query
-      #   end
-      def inherited(subclass)
-        super
-        ivs = subclass.instance_variables
-        inherited_instance_variables.each do |iv, dup|
-          next if ivs.include?(iv)
-          if (sup_class_value = instance_variable_get(iv)) && dup
-            sup_class_value = case dup
-            when :dup
-              sup_class_value.dup
-            when :hash_dup
-              h = {}
-              sup_class_value.each{|k,v| h[k] = v.dup}
-              h
-            when Proc
-              dup.call(sup_class_value)
-            else
-              raise Error, "bad inherited instance variable type: #{dup.inspect}"
-            end
-          end
-          subclass.instance_variable_set(iv, sup_class_value)
-        end
-
-        unless ivs.include?(:@dataset)
-          if @dataset && self != Model
-            subclass.set_dataset(@dataset.clone, :inherited=>true)
-          elsif (n = subclass.name) && !n.to_s.empty?
-            db
-            subclass.set_dataset(subclass.implicit_table_name)
-          end
-        end
-      end
-
       # Returns the implicit table name for the model class, which is the demodulized,
       # underscored, pluralized name of the class.
       #
@@ -515,12 +474,6 @@ module Sequel
         call(values)
       end
 
-      # Clear the setter_methods cache when a setter method is added.
-      def method_added(meth)
-        clear_setter_methods_cache if meth.to_s.end_with?('=')
-        super
-      end
-  
       # Mark the model as not having a primary key. Not having a primary key
       # can cause issues, among which is that you won't be able to update records.
       #
@@ -538,6 +491,11 @@ module Sequel
       # the module using a the camelized plugin name under Sequel::Plugins.
       def plugin(plugin, *args, &block)
         m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
+
+        if !m.respond_to?(:apply) && !m.respond_to?(:configure) && (!args.empty? || block)
+          Deprecation.deprecate("Plugin #{plugin} accepts no arguments or block, and passing arguments/block to it", "Remove arguments and block when loading the plugin")
+        end
+
         unless @plugins.include?(m)
           @plugins << m
           m.apply(self, *args, &block) if m.respond_to?(:apply)
@@ -547,8 +505,10 @@ module Sequel
             dataset_extend(m::DatasetMethods, :create_class_methods=>false)
           end
         end
+
         m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
+      ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
 
       # Returns primary key attribute hash.  If using a composite primary key
       # value such be an array with values for each primary key in the correct
@@ -640,7 +600,7 @@ module Sequel
           @columns = superclass.instance_variable_get(:@columns)
           @db_schema = superclass.instance_variable_get(:@db_schema)
         else
-          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse) if @dataset_method_modules
+          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse)
           @db_schema = get_db_schema
         end
 
@@ -679,8 +639,7 @@ module Sequel
   
       # Cache of setter methods to allow by default, in order to speed up mass assignment.
       def setter_methods
-        return @setter_methods if @setter_methods
-        @setter_methods = get_setter_methods
+        @setter_methods || (@setter_methods = get_setter_methods)
       end
 
       # Returns name of primary table for the dataset. If the table for the dataset
@@ -798,6 +757,7 @@ module Sequel
         else
           define_singleton_method(meth){|*args, &block| dataset.public_send(meth, *args, &block)}
         end
+        singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -854,6 +814,46 @@ module Sequel
         meths
       end
   
+      # If possible, set the dataset for the model subclass as soon as it
+      # is created.  Also, make sure the inherited class instance variables
+      # are copied into the subclass.
+      #
+      # Sequel queries the database to get schema information as soon as
+      # a model class is created:
+      #
+      #   class Artist < Sequel::Model # Causes schema query
+      #   end
+      def inherited(subclass)
+        super
+        ivs = subclass.instance_variables
+        inherited_instance_variables.each do |iv, dup|
+          if (sup_class_value = instance_variable_get(iv)) && dup
+            sup_class_value = case dup
+            when :dup
+              sup_class_value.dup
+            when :hash_dup
+              h = {}
+              sup_class_value.each{|k,v| h[k] = v.dup}
+              h
+            when Proc
+              dup.call(sup_class_value)
+            else
+              raise Error, "bad inherited instance variable type: #{dup.inspect}"
+            end
+          end
+          subclass.instance_variable_set(iv, sup_class_value)
+        end
+
+        unless ivs.include?(:@dataset)
+          if @dataset && self != Model
+            subclass.set_dataset(@dataset.clone, :inherited=>true)
+          elsif (n = subclass.name) && !n.to_s.empty?
+            db
+            subclass.set_dataset(subclass.implicit_table_name)
+          end
+        end
+      end
+
       # A hash of instance variables to automatically set up in subclasses.
       # Keys are instance variable symbols, values should be:
       # nil :: Assign directly from superclass to subclass (frozen objects)
@@ -908,6 +908,12 @@ module Sequel
         opts[:class_name] ||= '::' + ((name || '').split("::")[0..-2] + [camelize(default)]).join('::')
       end
   
+      # Clear the setter_methods cache when a setter method is added.
+      def method_added(meth)
+        clear_setter_methods_cache if meth.to_s.end_with?('=')
+        super
+      end
+  
       # Module that the class includes that holds methods the class adds for column accessors and
       # associations so that the methods can be overridden with +super+.
       def overridable_methods_module
@@ -1116,7 +1122,7 @@ module Sequel
         when nil
           return false
         when Array
-          return false if pk.any?(&:nil?)
+          return false if pkv.any?(&:nil?)
         end
 
         (obj.class == model) && (obj.pk == pkv)
@@ -1718,6 +1724,7 @@ module Sequel
 
       # The values hash to use when inserting a new record.
       alias _insert_values values
+      private :_insert_values
       
       # Refresh using a particular dataset, used inside save to make sure the same server
       # is used for reading newly inserted values from the database
@@ -2231,7 +2238,9 @@ module Sequel
     plugin self
 
     singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
+    # :nocov:
     if RUBY_VERSION >= '1.9.3'
+    # :nocov:
       singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
     end
   end

data/lib/sequel/model/plugins.rb

@@ -31,6 +31,7 @@ module Sequel
     def self.def_dataset_methods(mod, meths)
       Array(meths).each do |meth|
         mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
       end
     end
 
@@ -40,6 +41,7 @@ module Sequel
       mod.send(:define_method, :inherited_instance_variables) do ||
         super().merge!(hash)
       end
+      mod.send(:private, :inherited_instance_variables)
     end
 
     # Add method to +mod+ that overrides set_dataset to call the method afterward.
@@ -148,9 +150,8 @@ module Sequel
       required_args = arity
       arity -= 1 if keyword == :required
 
-      if callable.is_a?(Proc) && !callable.lambda?
-        optional_args -= arity
-      end
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
 
       [required_args, optional_args, rest, keyword]
     end

data/lib/sequel/plugins/association_lazy_eager_option.rb

@@ -36,6 +36,8 @@ module Sequel
     #   Album.plugin :association_lazy_eager_option
     module AssociationLazyEagerOption
       module InstanceMethods
+        private
+
         # Return a dataset for the association after applying any dynamic callback.
         def _associated_dataset(opts, dynamic_opts)
           ds = super

data/lib/sequel/plugins/association_multi_add_remove.rb

@@ -39,6 +39,8 @@ module Sequel
     #   Album.plugin :association_multi_add_remove
     module AssociationMultiAddRemove
       module ClassMethods
+        private
+
         # Define the methods use to add/remove/set multiple associated objects
         # in a single method call.
         def def_association_instance_methods(opts)

data/lib/sequel/plugins/association_pks.rb

@@ -2,13 +2,17 @@
 
 module Sequel
   module Plugins
-    # The association_pks plugin adds association_pks and association_pks=
-    # instance methods to the model class for each association added.  These
-    # methods allow for easily returning the primary keys of the associated
-    # objects, and easily modifying which objects are associated:
+    # The association_pks plugin adds association_pks, association_pks=, and
+    # association_pks_dataset instance methods to the model class for each
+    # one_to_many and many_to_many association added.  These methods allow for
+    # easily returning the primary keys of the associated objects, and easily
+    # modifying which objects are associated:
     #
     #   Artist.one_to_many :albums
     #   artist = Artist[1]
+    #   artist.album_pks_dataset
+    #   # SELECT id FROM albums WHERE (albums.artist_id = 1)
+    #
     #   artist.album_pks # [1, 2, 3]
     #   artist.album_pks = [2, 4]
     #   artist.album_pks # [2, 4]
@@ -22,11 +26,18 @@ module Sequel
     # This plugin makes modifications directly to the underlying tables,
     # it does not create or return any model objects, and therefore does
     # not call any callbacks.  If you have any association callbacks,
-    # you probably should not use the setter methods.
+    # you probably should not use the setter methods this plugin adds.
     #
     # By default, changes to the association will not happen until the object
-    # is saved.  However, using the delay_pks: false option, you can have the
-    # changes made immediately when the association_pks setter method is called.
+    # is saved.  However, using the delay_pks: false association option, you can have
+    # the changes made immediately when the association_pks setter method is called.
+    #
+    # By default, repeated calls to the association_pks getter method will not be
+    # cached, unless the setter method has been used and the delay_pks: false
+    # association option is not used.  You can set caching of repeated calls to the
+    # association_pks getter method using the :cache_pks association option.  You can
+    # pass the :refresh option when calling the getter method to ignore any existing
+    # cached values, similar to how the :refresh option works with associations.
     #
     # By default, if you pass a nil value to the setter, an exception will be raised.
     # You can change this behavior by using the :association_pks_nil association option.
@@ -60,9 +71,11 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
+          association_module_def(opts[:pks_dataset_method], &opts[:pks_dataset])
+
           opts[:pks_getter_method] = :"#{singularize(opts[:name])}_pks_getter"
           association_module_def(opts[:pks_getter_method], &opts[:pks_getter])
-          association_module_def(:"#{singularize(opts[:name])}_pks", opts){_association_pks_getter(opts)}
+          association_module_def(:"#{singularize(opts[:name])}_pks", opts){|dynamic_opts=OPTS| _association_pks_getter(opts, dynamic_opts)}
 
           if opts[:pks_setter]
             opts[:pks_setter_method] = :"#{singularize(opts[:name])}_pks_setter"
@@ -84,7 +97,9 @@ module Sequel
           clpk = lpk.is_a?(Array)
           crk = rk.is_a?(Array)
 
-          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+          dataset_method = opts[:pks_dataset_method] = :"#{singularize(opts[:name])}_pks_dataset"
+
+          opts[:pks_dataset] = if join_associated_table = opts[:association_pks_use_associated_table]
             tname = opts[:join_table]
             lambda do
               cond = if clpk
@@ -95,16 +110,26 @@ module Sequel
               rpk = opts.associated_class.primary_key
               opts.associated_dataset.
                 naked.where(cond).
-                select_map(Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
+                select(*Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
             end
           elsif clpk
             lambda do
               cond = lk.zip(lpk).map{|k, pk| [k, get_column_value(pk)]}
-              _join_table_dataset(opts).where(cond).select_map(rk)
+              _join_table_dataset(opts).where(cond).select(*rk)
+            end
+          else
+            lambda do
+              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select(*rk)
+            end
+          end
+
+          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+            lambda do
+              public_send(dataset_method).map(opts.associated_class.primary_key)
             end
           else
             lambda do
-              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select_map(rk)
+              public_send(dataset_method).map(rk)
             end
           end
 
@@ -145,8 +170,14 @@ module Sequel
 
           key = opts[:key]
 
+          dataset_method = opts[:pks_dataset_method] = :"#{singularize(opts[:name])}_pks_dataset"
+
+          opts[:pks_dataset] = lambda do
+            public_send(opts[:dataset_method]).select(*opts.associated_class.primary_key)
+          end
+
           opts[:pks_getter] = lambda do
-            public_send(opts[:dataset_method]).select_map(opts.associated_class.primary_key)
+            public_send(dataset_method).map(opts.associated_class.primary_key)
           end
 
           unless opts[:read_only]
@@ -207,12 +238,22 @@ module Sequel
         # Return the primary keys of the associated objects.
         # If the receiver is a new object, return any saved
         # pks, or an empty array if no pks have been saved.
-        def _association_pks_getter(opts)
+        def _association_pks_getter(opts, dynamic_opts=OPTS)
+          do_cache = opts[:cache_pks]
           delay = opts.fetch(:delay_pks, true)
-          if new? && delay
+          cache_or_delay = do_cache || delay
+
+          if dynamic_opts[:refresh] && @_association_pks
+            @_association_pks.delete(opts[:name])
+          end
+
+          if new? && cache_or_delay
             (@_association_pks ||= {})[opts[:name]] ||= []
-          elsif delay && @_association_pks && (objs = @_association_pks[opts[:name]])
+          elsif cache_or_delay && @_association_pks && (objs = @_association_pks[opts[:name]])
             objs
+          elsif do_cache
+           # pks_getter_method is private
+            (@_association_pks ||= {})[opts[:name]] = send(opts[:pks_getter_method])
           else
            # pks_getter_method is private
             send(opts[:pks_getter_method])
@@ -254,9 +295,10 @@ module Sequel
 
           if primary_key.is_a?(Array)
             if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?
+              db = model.db
               pks.map do |cpk|
-                cpk.zip(convs).map do |pk, conv|
-                  conv ? model.db.typecast_value(:integer, pk) : pk
+                cpk.map do |pk|
+                  db.typecast_value(:integer, pk)
                 end
               end
             else

data/lib/sequel/plugins/association_proxies.rb

@@ -99,6 +99,7 @@ module Sequel
           end
           v.public_send(meth, *args, &block)
         end
+        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
       end
 
       module ClassMethods
@@ -109,6 +110,8 @@ module Sequel
 
         Plugins.inherited_instance_variables(self, :@association_proxy_to_dataset=>nil)
 
+        private
+
         # Changes the association method to return a proxy instead of the associated objects
         # directly.
         def def_association_method(opts)

data/lib/sequel/plugins/blacklist_security.rb

@@ -58,8 +58,7 @@ module Sequel
         # restricted_columns.
         def get_setter_methods
           meths = super
-          #if !(respond_to?(:allowed_columns) && allowed_columns) && restricted_columns
-          if (!defined?(::Sequel::Plugins::WhitelistSecurity) || !plugins.include?(::Sequel::Plugins::WhitelistSecurity) || !allowed_columns) && restricted_columns
+          if (!defined?(::Sequel::Plugins::WhitelistSecurity::ClassMethods) || !is_a?(::Sequel::Plugins::WhitelistSecurity::ClassMethods) || !allowed_columns) && restricted_columns
             meths -= restricted_columns.map{|x| "#{x}="}
           end
           meths

data/lib/sequel/plugins/boolean_subsets.rb

@@ -31,7 +31,10 @@ module Sequel
       # Create boolean subset methods for each boolean column.
       def self.configure(model, &block)
         model.instance_exec do
-          define_singleton_method(:boolean_subset_args, &block) if block
+          if block
+            define_singleton_method(:boolean_subset_args, &block)
+            singleton_class.send(:private, :boolean_subset_args)
+          end
           create_boolean_subsets if @dataset
         end
       end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -278,6 +278,27 @@ module Sequel
 
         Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil, :@cti_ignore_subclass_columns=>nil, :@cti_qualify_tables=>nil)
 
+        # The table name for the current model class's main table.
+        def table_name
+          if cti_tables && cti_tables.length > 1
+            @cti_alias
+          else
+            super
+          end
+        end
+
+        # The name of the most recently joined table.
+        def cti_table_name
+          cti_tables.last
+        end
+
+        # The model class for the given key value.
+        def sti_class_from_key(key)
+          sti_class(sti_model_map[key])
+        end
+
+        private
+
         def inherited(subclass)
           ds = sti_dataset
 
@@ -289,7 +310,7 @@ module Sequel
           # Set table if this is a class table inheritance
           table = nil
           columns = nil
-          if (n = subclass.name) && !n.empty?
+          if n = subclass.name
             if table = cti_table_map[n.to_sym]
               columns = db.schema(table).map(&:first)
             else
@@ -340,27 +361,6 @@ module Sequel
           end
         end
 
-        # The table name for the current model class's main table.
-        def table_name
-          if cti_tables && cti_tables.length > 1
-            @cti_alias
-          else
-            super
-          end
-        end
-
-        # The name of the most recently joined table.
-        def cti_table_name
-          cti_tables ? cti_tables.last : dataset.first_source_alias
-        end
-
-        # The model class for the given key value.
-        def sti_class_from_key(key)
-          sti_class(sti_model_map[key])
-        end
-
-        private
-
         # If using a subquery for class table inheritance, also use a subquery
         # when setting subclass dataset.
         def sti_subclass_dataset(key)
@@ -383,11 +383,6 @@ module Sequel
           self
         end
 
-        # Don't allow use of prepared statements.
-        def use_prepared_statements_for?(type)
-          false
-        end
-
         # Set the sti_key column based on the sti_key_map.
         def before_validation
           if new? && (set = self[model.sti_key])
@@ -422,7 +417,7 @@ module Sequel
               @values[primary_key] ||= nid
             end
           end
-          db.dataset.supports_insert_select? ? nil : @values[primary_key]
+          @values[primary_key]
         end
 
         # Update rows in all backing tables, using the columns in each table.
@@ -438,6 +433,11 @@ module Sequel
             end
           end
         end
+
+        # Don't allow use of prepared statements.
+        def use_prepared_statements_for?(type)
+          false
+        end
       end
     end
   end