sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/association_proxies.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # Sequel by default does not use proxies for associations.  The association
@@ -35,7 +37,7 @@ module Sequel
     #     :arguments => [2],
     #     :block => {|x| 3},
     #     :instance => artist,
-    #     :reflection => {:name=>:albums} # AssociationReflection instance 
+    #     :reflection => AssociationReflection instance,
     #     :proxy_argument => 1,
     #     :proxy_block => {|ds| ds}
     #   }
@@ -49,7 +51,7 @@ module Sequel
     #   Album.plugin :association_proxies
     module AssociationProxies
       def self.configure(model, &block)
-        model.instance_eval do
+        model.instance_exec do
           @association_proxy_to_dataset = block if block
           @association_proxy_to_dataset ||= AssociationProxy::DEFAULT_PROXY_TO_DATASET
         end
@@ -59,11 +61,24 @@ module Sequel
       # associated objects and call the method on the associated object array.
       # Calling any other method will call that method on the association's dataset.
       class AssociationProxy < BasicObject
-        array = []
+        array = [].freeze
+
+        if RUBY_VERSION < '2.6'
+          # :nocov:
 
-        # Default proc used to determine whether to sent the method to the dataset.
-        # If the array would respond to it, sends it to the array instead of the dataset.
-        DEFAULT_PROXY_TO_DATASET = proc{|opts| !array.respond_to?(opts[:method])}
+          # Default proc used to determine whether to send the method to the dataset.
+          # If the array would respond to it, sends it to the array instead of the dataset.
+          DEFAULT_PROXY_TO_DATASET = proc do |opts|
+            array_method = array.respond_to?(opts[:method])
+            if !array_method && opts[:method] == :filter
+              Sequel::Deprecation.deprecate "The behavior of the #filter method for association proxies will change in Ruby 2.6. Switch from using #filter to using #where to conserve current behavior."
+            end
+            !array_method
+          end
+          # :nocov:
+        else
+          DEFAULT_PROXY_TO_DATASET = proc{|opts| !array.respond_to?(opts[:method])}
+        end
 
         # Set the association reflection to use, and whether the association should be
         # reloaded if an array method is called.
@@ -78,12 +93,13 @@ module Sequel
         # is an array method, otherwise call the method on the association's dataset.
         def method_missing(meth, *args, &block)
           v = if @instance.model.association_proxy_to_dataset.call(:method=>meth, :arguments=>args, :block=>block, :instance=>@instance, :reflection=>@reflection, :proxy_argument=>@proxy_argument, :proxy_block=>@proxy_block)
-            @instance.send(@reflection.dataset_method)
+            @instance.public_send(@reflection[:dataset_method])
           else
             @instance.send(:load_associated_objects, @reflection, @proxy_argument, &@proxy_block)
           end
-          v.send(meth, *args, &block)
+          v.public_send(meth, *args, &block)
         end
+        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
       end
 
       module ClassMethods
@@ -94,10 +110,18 @@ 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)
-          opts.returns_array? ? association_module_def(opts.association_method, opts){|*r, &block| AssociationProxy.new(self, opts, r[0], &block)} : super
+          if opts.returns_array?
+            association_module_def(opts.association_method, opts) do |dynamic_opts=OPTS, &block|
+              AssociationProxy.new(self, opts, dynamic_opts, &block)
+            end
+          else
+            super
+          end
         end
       end
     end

data/lib/sequel/plugins/auto_validations.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The auto_validations plugin automatically sets up the following types of validations
@@ -28,10 +30,16 @@ module Sequel
     #
     #   Model.skip_auto_validations(:all)
     #
+    # It is possible to skip auto validations on a per-model-instance basis via:
+    #
+    #   instance.skip_auto_validations(:unique, :not_null) do
+    #     puts instance.valid?
+    #   end
+    #
     # By default, the plugin uses a not_null validation for NOT NULL columns, but that
     # can be changed to a presence validation using an option:
     #
-    #   Model.plugin :auto_validations, :not_null=>:presence
+    #   Model.plugin :auto_validations, not_null: :presence
     #
     # This is useful if you want to enforce that NOT NULL string columns do not
     # allow empty values.
@@ -56,9 +64,10 @@ module Sequel
       MAX_LENGTH_OPTIONS = {:from=>:values, :allow_nil=>true}.freeze
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
+      EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           plugin :validation_helpers
           @auto_validate_presence = false
           @auto_validate_not_null_columns = []
@@ -79,7 +88,7 @@ module Sequel
 
       # Setup auto validations for the model if it has a dataset.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           setup_auto_validations if @dataset
           if opts[:not_null] == :presence
             @auto_validate_presence = true
@@ -125,15 +134,29 @@ module Sequel
           @auto_validate_types
         end
 
+        # Freeze auto_validation settings when freezing model class.
+        def freeze
+          @auto_validate_not_null_columns.freeze
+          @auto_validate_explicit_not_null_columns.freeze
+          @auto_validate_max_length_columns.freeze
+          @auto_validate_unique_columns.freeze
+
+          super
+        end
+
         # Skip automatic validations for the given validation type (:not_null, :types, :unique).
         # If :all is given as the type, skip all auto validations.
         def skip_auto_validations(type)
-          if type == :all
+          case type
+          when :all
             [:not_null, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
-          elsif type == :types
+          when :not_null
+            auto_validate_not_null_columns.clear
+            auto_validate_explicit_not_null_columns.clear
+          when :types
             @auto_validate_types = false
           else
-            send("auto_validate_#{type}_columns").clear
+            public_send("auto_validate_#{type}_columns").clear
           end
         end
 
@@ -156,38 +179,50 @@ module Sequel
       end
 
       module InstanceMethods
+        # Skip the given types of auto validations on this instance inside the block.
+        def skip_auto_validations(*types)
+          types << :all if types.empty?
+          @_skip_auto_validations = types
+          yield
+        ensure
+          @_skip_auto_validations = nil
+        end
+
         # Validate the model's auto validations columns
         def validate
           super
+          skip = @_skip_auto_validations || EMPTY_ARRAY
+          return if skip.include?(:all)
           opts = model.auto_validate_options
 
-          unless (not_null_columns = model.auto_validate_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:not_null])
-            else
-              validates_not_null(not_null_columns, opts[:not_null])
+
+          unless skip.include?(:not_null)
+            not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null
+            unless (not_null_columns = model.auto_validate_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:not_null])
             end
-          end
-          unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:explicit_not_null])
-            else
-              validates_not_null(not_null_columns, opts[:explicit_not_null])
+            unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:explicit_not_null])
             end
           end
-          unless (max_length_columns = model.auto_validate_max_length_columns).empty?
+
+          unless skip.include?(:max_length) || (max_length_columns = model.auto_validate_max_length_columns).empty?
             max_length_columns.each do |col, len|
               validates_max_length(len, col, opts[:max_length])
             end
           end
 
-          validates_schema_types(keys, opts[:schema_types]) if model.auto_validate_types?
+          unless skip.include?(:types) || !model.auto_validate_types?
+            validates_schema_types(keys, opts[:schema_types])
+          end
 
-          unique_opts = Hash[opts[:unique]]
-          if model.respond_to?(:sti_dataset)
-            unique_opts[:dataset] = model.sti_dataset
+          unless skip.include?(:unique)
+            unique_opts = Hash[opts[:unique]]
+            if model.respond_to?(:sti_dataset)
+              unique_opts[:dataset] = model.sti_dataset
+            end
+            model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
           end
-          model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
         end
       end
     end

data/lib/sequel/plugins/before_after_save.rb

@@ -0,0 +1,8 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module BeforeAfterSave
+    end
+  end
+end

data/lib/sequel/plugins/blacklist_security.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The blacklist_security plugin contains blacklist-based support for
@@ -13,12 +15,25 @@ module Sequel
     #   # Make the Album class support the blacklist security features.
     #   Album.plugin :blacklist_security
     module BlacklistSecurity
+      # Special array subclass used for marking methods to be removed.
+      class ExceptionList < Array
+      end
+
       module ClassMethods
         # Which columns are specifically restricted in a call to set/update/new/etc.
         # (default: not set).  Some columns are restricted regardless of
         # this setting, such as the primary key column and columns in Model::RESTRICTED_SETTER_METHODS.
         attr_reader :restricted_columns
   
+        Plugins.inherited_instance_variables(self, :@restricted_columns=>:dup)
+
+        # Freeze restricted columns when freezing model class.
+        def freeze
+          @restricted_columns.freeze
+
+          super
+        end
+
         # Set the columns to restrict when using mass assignment (e.g. +set+).  Using this means that
         # attempts to call setter methods for the columns listed here will cause an
         # exception or be silently skipped (based on the +strict_param_setting+ setting).
@@ -26,12 +41,12 @@ module Sequel
         # want not to be used during mass assignment, they need to be listed here as well (without the =).
         #
         # It's generally a bad idea to rely on a blacklist approach for security.  Using a whitelist
-        # approach such as set_allowed_columns or the instance level set_only or set_fields methods
+        # approach such as the whitelist_security plugin or the set_fields methods
         # is usually a better choice.  So use of this method is generally a bad idea.
         #
         #   Artist.set_restricted_columns(:records_sold)
-        #   Artist.set(:name=>'Bob', :hometown=>'Sactown') # No Error
-        #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
+        #   Artist.set(name: 'Bob', hometown: 'Sactown') # No Error
+        #   Artist.set(name: 'Bob', records_sold: 30000) # Error
         def set_restricted_columns(*cols)
           clear_setter_methods_cache
           @restricted_columns = cols
@@ -43,7 +58,7 @@ module Sequel
         # restricted_columns.
         def get_setter_methods
           meths = super
-          if !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
@@ -51,25 +66,21 @@ module Sequel
       end
 
       module InstanceMethods
-        # Special array subclass used for marking methods to be removed.
-        class ExceptionList < Array
-        end
-
         # Set all values using the entries in the hash, except for the keys
-        # given in except.  You should probably use +set_fields+ or +set_only+
+        # given in except.  You should probably use +set_fields+
         # instead of this method, as blacklist approaches to security are a bad idea.
         #
-        #   artist.set_except({:name=>'Jim'}, :hometown)
+        #   artist.set_except({name: 'Jim'}, :hometown)
         #   artist.name # => 'Jim'
         def set_except(hash, *except)
           set_restricted(hash, ExceptionList.new(except.flatten))
         end
     
         # Update all values using the entries in the hash, except for the keys
-        # given in except.  You should probably use +update_fields+ or +update_only+
+        # given in except.  You should probably use +update_fields+
         # instead of this method, as blacklist approaches to security are a bad idea.
         #
-        #   artist.update_except({:name=>'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        #   artist.update_except({name: 'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
         def update_except(hash, *except)
           update_restricted(hash, ExceptionList.new(except.flatten))
         end

data/lib/sequel/plugins/boolean_readers.rb

@@ -1,6 +1,8 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # The BooleanReaders plugin allows for the creation of attribute? methods
+    # The boolean_readers plugin allows for the creation of attribute? methods
     # for boolean columns, which provides a nicer API.  By default, the accessors
     # are created for all columns of type :boolean.  However, you can provide a
     # block to the plugin to change the criteria used to determine if a
@@ -26,8 +28,8 @@ module Sequel
       # Add the boolean_attribute? class method to the model, and create
       # attribute? boolean reader methods for the class's columns if the class has a dataset.
       def self.configure(model, &block)
-        model.instance_eval do
-          (class << self; self; end).send(:define_method, :boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+        model.instance_exec do
+          define_singleton_method(:boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
           send(:create_boolean_readers) if @dataset
         end
       end
@@ -46,9 +48,10 @@ module Sequel
 
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
-          im = instance_methods.collect(&:to_s)
-          cs = columns rescue return
-          cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+          im = instance_methods.map(&:to_s)
+          if cs = check_non_connection_error(false){columns}
+            cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+          end
         end
       end
     end

data/lib/sequel/plugins/boolean_subsets.rb

@@ -0,0 +1,64 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The boolean_subsets plugin allows for the automatic creation of subsets for
+    # for boolean columns, which can DRY up model classes that define such subsets
+    # manually.  By default, subsets are created for all columns of type :boolean,
+    # with the subset name being the same as column name, and the conditions being
+    # <tt>column IS TRUE</tt> (assuming the database supports that syntax).
+    #
+    # You can provide a block to the plugin, which will be called with column name
+    # symbol, and should return an array of arguments to pass to +dataset_module.where+.
+    # Using this, you can change the method name and arguments for each column.
+    # This block is executed in the context of the model class.
+    #
+    # Usage:
+    #
+    #   # Add boolean subset methods for all columns of type :boolean
+    #   # in all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :boolean_subsets
+    #
+    #   # Add subsets for all boolean columns in the Album class
+    #   Album.plugin(:boolean_subsets)
+    #
+    #   # Remove is_ from the front of the column name when creating the subset
+    #   # method name, and use (column = 'Y') as the filter conditions
+    #   Sequel::Model.plugin :boolean_subsets do |column|
+    #     [column.to_s.sub(/\Ais_/, ''), {column=>'Y'}]
+    #   end
+    module BooleanSubsets
+      # Create boolean subset methods for each boolean column.
+      def self.configure(model, &block)
+        model.instance_exec do
+          if block
+            define_singleton_method(:boolean_subset_args, &block)
+            singleton_class.send(:private, :boolean_subset_args)
+          end
+          create_boolean_subsets if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :create_boolean_subsets)
+
+        private
+
+        # The arguments to use when automatically defining a boolean subset for the given column.
+        def boolean_subset_args(c)
+          [c, {c=>true}]
+        end
+
+        # Add subset methods for all of the boolean columns in this model.
+        def create_boolean_subsets
+          if cs = check_non_connection_error(false){columns}
+            cs = cs.select{|c| db_schema[c][:type] == :boolean}.map{|c| boolean_subset_args(c)}
+            dataset_module do
+              cs.each{|c| where(*c)}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/caching.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # Sequel's built-in caching plugin supports caching to any object that
@@ -17,8 +19,16 @@ module Sequel
     # raise an exception for a missing record, so if you use memcached, you will
     # want to use this option.
     #
-    # Note that only Model.[] method calls with a primary key argument are cached
-    # using this plugin.
+    # Note that only lookups by primary key are cached using this plugin.  The following
+    # methods use a lookup by primary key:
+    #
+    # * Model.with_pk
+    # * Model.with_pk!
+    # * Model.[] # when argument is not hash or nil
+    # * many_to_one association method # without dynamic callback, when primary key matches
+    #
+    # You should not use this plugin if you are using sharding and there are different
+    # rows for the same primary key on different shards.
     # 
     # Usage:
     #
@@ -27,15 +37,15 @@ module Sequel
     #   Sequel::Model.plugin :caching, CACHE
     #
     #   # Make the Album class use the cache with a 30 minute time-to-live
-    #   Album.plugin :caching, CACHE, :ttl=>1800
+    #   Album.plugin :caching, CACHE, ttl: 1800
     #
     #   # Make the Artist class use a cache with the memcached protocol
-    #   Artist.plugin :caching, MEMCACHED_CACHE, :ignore_exceptions=>true
+    #   Artist.plugin :caching, MEMCACHED_CACHE, ignore_exceptions: true
     module Caching
       # Set the cache_store and cache_ttl attributes for the given model.
       # If the :ttl option is not given, 3600 seconds is the default.
       def self.configure(model, store, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @cache_store = store
           @cache_ttl = opts[:ttl] || 3600
           @cache_ignore_exceptions = opts[:ignore_exceptions]
@@ -66,7 +76,7 @@ module Sequel
 
         # Returns the prefix used to namespace this class in the cache.
         def cache_key_prefix
-          "#{self}"
+          to_s
         end
 
         # Return a key string for the given primary key.
@@ -84,26 +94,27 @@ module Sequel
         
         private
     
-        # Delete the entry with the matching key from the cache
-        def cache_delete(ck)
+        # Access the cache using the given method and key, rescuing exceptions if necessary.
+        def cache_op(meth, ck)
           if @cache_ignore_exceptions
-            @cache_store.delete(ck) rescue nil
+            @cache_store.public_send(meth, ck) rescue nil
           else
-            @cache_store.delete(ck)
+            @cache_store.public_send(meth, ck)
           end
+        end
+    
+        # Delete the entry with the matching key from the cache
+        def cache_delete(ck)
+          cache_op(:delete, ck)
           nil
         end
         
         # Returned the cached object, or nil if the object was not
         # in the cached
         def cache_get(ck)
-          if @cache_ignore_exceptions
-            @cache_store.get(ck) rescue nil
-          else
-            @cache_store.get(ck)
-          end
+          cache_op(:get, ck)
         end
-    
+
         # Set the object in the cache_store with the given key for cache_ttl seconds.
         def cache_set(ck, obj)
           @cache_store.set(ck, obj, @cache_ttl)