sequel 3.47.0 → 3.48.0

data/lib/sequel/model/errors.rb

@@ -10,14 +10,19 @@ module Sequel
       # to add new error messages, and +on+ to check existing
       # error messages.
       def [](k)
-        has_key?(k) ? super : (self[k] = [])
+        if has_key?(k)
+          super
+        else
+          Sequel::Deprecation.deprecate('Model::Errors#[] autovivification', 'Please switch to Model::Errors#add to add errors, and Model::Errors#on to get errors')
+          self[k] = []
+        end
       end
 
       # Adds an error for the given attribute.
       #
       #   errors.add(:name, 'is not valid') if name == 'invalid'
       def add(att, msg)
-        self[att] << msg
+        fetch(att){self[att] = []} << msg
       end
 
       # Return the total number of error messages.

data/lib/sequel/plugins/active_model.rb

@@ -16,6 +16,14 @@ module Sequel
     #   # Make the Album class active_model compliant
     #   Album.plugin :active_model
     module ActiveModel
+      # ActiveModel compliant error class
+      class Errors < Sequel::Model::Errors
+        # Add autovivification so that #[] always returns an array.
+        def [](k)
+          fetch(k){self[k] = []}
+        end
+      end
+
       module ClassMethods
         include ::ActiveModel::Naming
         
@@ -70,6 +78,11 @@ module Sequel
         end
         
         private
+
+        # Use ActiveModel compliant errors class.
+        def errors_class
+          Errors
+        end
         
         # The string to use to join composite primary key param strings.
         def to_param_joiner

data/lib/sequel/plugins/after_initialize.rb

@@ -0,0 +1,43 @@
+module Sequel
+  module Plugins
+    # Adds an after_initialize hook to models, called after initializing
+    # both new objects and ones loaded from the database.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support the after_initialize hook
+    #   Sequel::Model.plugin :after_initialize
+    #
+    #   # Make the Album class support the after_initialize hook
+    #   Album.plugin :after_initialize
+    module AfterInitialize
+      module ClassMethods
+        # Call after_initialize for model objects loaded from the database.
+        #def call
+        #  v = super
+        #  v.after_initialize
+        #  v
+        #end
+
+        private
+
+        # REMOVE40
+        def check_deprecated_after_initialize(meths)
+        end
+      end
+
+      module InstanceMethods
+        # Call after_initialize for new model objects.
+        #def initialize(h={})
+        #  super
+        #  after_initialize
+        #end
+        
+        # An empty after_initialize hook, so that plugins that use this
+        # can always call super to get the default behavior.
+        #def after_initialize
+        #end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_proxies.rb

@@ -6,6 +6,40 @@ module Sequel
     # that will load the association and call a method on the association array if sent
     # an array method, and otherwise send the method to the association's dataset.
     # 
+    # You can override which methods to forward to the dataset by passing a block to the plugin:
+    #
+    #   plugin :association_proxies do |opts|
+    #     [:find, :where, :create].include?(opts[:method])
+    #   end
+    #
+    # If the block returns false or nil, the method is sent to the array of associated
+    # objects.  Otherwise, the method is sent to the association dataset.  Here are the entries
+    # in the hash passed to the block:
+    #
+    # :method :: The name of the method
+    # :arguments :: The arguments to the method
+    # :block :: The block given to the method
+    # :instance :: The model instance related to the call
+    # :reflection :: The reflection for the association related to the call
+    # :proxy_argument :: The argument given to the association method call
+    # :proxy_block :: The block given to the association method call
+    # 
+    # For example, in a call like:
+    #
+    #   artist.albums(1){|ds| ds}.foo(2){|x| 3}
+    #
+    # The opts passed to the block would be:
+    #
+    #   {
+    #     :method => :foo,
+    #     :arguments => [2],
+    #     :block => {|x| 3},
+    #     :instance => artist,
+    #     :reflection => {:name=>:albums, ...},
+    #     :proxy_argument => 1,
+    #     :proxy_block => {|ds| ds}
+    #   }
+    #
     # Usage:
     #
     #   # Use association proxies in all model subclasses (called before loading subclasses)
@@ -14,34 +48,56 @@ module Sequel
     #   # Use association proxies in a specific model subclass
     #   Album.plugin :association_proxies
     module AssociationProxies
+      def self.configure(model, &block)
+        model.instance_eval do
+          @association_proxy_to_dataset = block if block
+          @association_proxy_to_dataset ||= AssociationProxy::DEFAULT_PROXY_TO_DATASET
+        end
+      end
+
       # A proxy for the association.  Calling an array method will load the
       # 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
-        # Empty array used to check if an array responds to the given method.
-        ARRAY = []
+        array = []
+
+        # 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])}
 
         # Set the association reflection to use, and whether the association should be
         # reloaded if an array method is called.
-        def initialize(instance, reflection, reload=nil)
+        def initialize(instance, reflection, proxy_argument, &proxy_block)
           @instance = instance
           @reflection = reflection
-          @reload = reload
+          @proxy_argument = proxy_argument
+          @proxy_block = proxy_block
         end
 
         # Call the method given on the array of associated objects if the method
         # is an array method, otherwise call the method on the association's dataset.
         def method_missing(meth, *args, &block)
-          (ARRAY.respond_to?(meth) ? @instance.send(:load_associated_objects, @reflection, @reload) : @instance.send(@reflection.dataset_method)).
-            send(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)
+          else
+            @instance.send(:load_associated_objects, @reflection, @proxy_argument, &@proxy_block)
+          end
+          v.send(meth, *args, &block)
         end
       end
 
       module ClassMethods
+        # Proc that accepts a method name, array of arguments, and block and
+        # should return a truthy value to send the method to the dataset instead of the
+        # array of associated objects.
+        attr_reader :association_proxy_to_dataset
+
+        Plugins.inherited_instance_variables(self, :@association_proxy_to_dataset=>nil)
+
         # 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| AssociationProxy.new(self, opts, r[0])} : super
+          opts.returns_array? ? association_module_def(opts.association_method, opts){|*r, &block| AssociationProxy.new(self, opts, r[0], &block)} : super
         end
       end
     end

data/lib/sequel/plugins/auto_validations.rb

@@ -4,10 +4,10 @@ module Sequel
     # for your model columns:
     #
     # 1. type validations for all columns
-    # 2. presence validations on NOT NULL columns
+    # 2. not_null validations on NOT NULL columns (optionally, presence validations)
     # 3. unique validations on columns or sets of columns with unique indexes
     #
-    # To determine the columns to use for the presence validations and the types for the type validations,
+    # To determine the columns to use for the not_null validations and the types for the type validations,
     # the plugin looks at the database schema for the model's table.  To determine
     # the unique validations, Sequel looks at the indexes on the table.  In order
     # for this plugin to be fully functional, the underlying database adapter needs
@@ -20,13 +20,21 @@ module Sequel
     #
     # You can skip certain types of validations from being automatically added via:
     #
-    #   Model.skip_auto_validations(:presence)
+    #   Model.skip_auto_validations(:not_null)
     #
     # If you want to skip all auto validations (only useful if loading the plugin
     # in a superclass):
     #
     #   Model.skip_auto_validations(:all)
     #
+    # 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
+    #
+    # This is useful if you want to enforce that NOT NULL string columns do not
+    # allow empty values.
+    #
     # Usage:
     #
     #   # Make all model subclass use auto validations (called before loading subclasses)
@@ -35,43 +43,61 @@ module Sequel
     #   # Make the Album class use auto validations
     #   Album.plugin :auto_validations
     module AutoValidations
-      # Load the validation_helpers plugin and setup data structures.
-      def self.apply(model)
+      def self.apply(model, opts={})
         model.instance_eval do
           plugin :validation_helpers
-          @auto_validate_presence_columns = []
+          @auto_validate_presence = false
+          @auto_validate_not_null_columns = []
+          @auto_validate_explicit_not_null_columns = []
           @auto_validate_unique_columns = []
           @auto_validate_types = true
         end
       end
 
       # Setup auto validations for the model if it has a dataset.
-      def self.configure(model)
+      def self.configure(model, opts={})
         model.instance_eval do
           setup_auto_validations if @dataset
+          if opts[:not_null] == :presence
+            @auto_validate_presence = true
+          end
         end
       end
 
       module ClassMethods
-        # The columns with automatic presence validations
-        attr_reader :auto_validate_presence_columns
+        # The columns with automatic not_null validations
+        attr_reader :auto_validate_not_null_columns
+
+        # The columns with automatic not_null validations for columns present in the values.
+        attr_reader :auto_validate_explicit_not_null_columns
 
         # The columns or sets of columns with automatic unique validations
         attr_reader :auto_validate_unique_columns
 
-        Plugins.inherited_instance_variables(self, :@auto_validate_types=>nil, :@auto_validate_presence_columns=>:dup, :@auto_validate_unique_columns=>:dup)
+        Plugins.inherited_instance_variables(self, :@auto_validate_presence=>nil, :@auto_validate_types=>nil, :@auto_validate_not_null_columns=>:dup, :@auto_validate_explicit_not_null_columns=>:dup, :@auto_validate_unique_columns=>:dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
 
+        # REMOVE40
+        def auto_validate_presence_columns
+          Sequel::Deprecation.deprecate('Model.auto_validate_presence_columns', 'Please switch to auto_validate_not_null_columns')
+          auto_validate_not_null_columns
+        end
+
+        # Whether to use a presence validation for not null columns
+        def auto_validate_presence?
+          @auto_validate_presence
+        end
+
         # Whether to automatically validate schema types for all columns
         def auto_validate_types?
           @auto_validate_types
         end
 
-        # Skip automatic validations for the given validation type (:presence, :types, :unique).
+        # 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
-            [:presence, :types, :unique].each{|v| skip_auto_validations(v)}
+            [:not_null, :types, :unique].each{|v| skip_auto_validations(v)}
           elsif type == :types
             @auto_validate_types = false
           else
@@ -83,8 +109,11 @@ module Sequel
 
         # Parse the database schema and indexes and record the columns to automatically validate.
         def setup_auto_validations
-          @auto_validate_presence_columns = db_schema.select{|col, sch| sch[:allow_null] == false && sch[:ruby_default].nil?}.map{|col, sch| col} - Array(primary_key)
-          @auto_validate_unique_columns = if db.respond_to?(:indexes) 
+          not_null_cols, explicit_not_null_cols = db_schema.select{|col, sch| sch[:allow_null] == false}.partition{|col, sch| sch[:ruby_default].nil?}.map{|cs| cs.map{|col, sch| col}}
+          @auto_validate_not_null_columns = not_null_cols - Array(primary_key)
+          explicit_not_null_cols += Array(primary_key)
+          @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
+          @auto_validate_unique_columns = if db.supports_index_parsing?
             db.indexes(dataset.first_source_table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns]}
           else
             []
@@ -96,8 +125,19 @@ module Sequel
         # Validate the model's auto validations columns
         def validate
           super
-          if presence_columns = model.auto_validate_presence_columns
-            validates_not_null(presence_columns)
+          unless (not_null_columns = model.auto_validate_not_null_columns).empty?
+            if model.auto_validate_presence?
+              validates_presence(not_null_columns)
+            else
+              validates_not_null(not_null_columns)
+            end
+          end
+          unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
+            if model.auto_validate_presence?
+              validates_presence(not_null_columns, :allow_missing=>true)
+            else
+              validates_not_null(not_null_columns, :allow_missing=>true)
+            end
           end
 
           validates_schema_types if model.auto_validate_types?

data/lib/sequel/plugins/blacklist_security.rb

@@ -0,0 +1,63 @@
+module Sequel
+  module Plugins
+    # The blacklist_security plugin contains blacklist-based support for
+    # mass assignment, specifying which columns to not allow mass assignment for,
+    # implicitly allowing mass assignment for columns not listed.  This is only
+    # for backwards compatibility, it should not be used by new code.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support the blacklist security features. 
+    #   Sequel::Model.plugin :blacklist_security
+    #
+    #   # Make the Album class support the blacklist security features.
+    #   Album.plugin :blacklist_security
+    module BlacklistSecurity
+      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
+  
+        # 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).
+        # If you have any virtual setter methods (methods that end in =) that you
+        # 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
+        # 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
+        def set_restricted_columns(*cols)
+          clear_setter_methods_cache
+          @restricted_columns = cols
+        end
+      end
+
+      module InstanceMethods
+        # 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+
+        # instead of this method, as blacklist approaches to security are a bad idea.
+        #
+        #   artist.set_except({:name=>'Jim'}, :hometown)
+        #   artist.name # => 'Jim'
+        def set_except(hash, *except)
+          set_restricted(hash, false, 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+
+        # 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)
+        def update_except(hash, *except)
+          update_restricted(hash, false, except.flatten)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -175,6 +175,15 @@ module Sequel
         def table_name
           self == cti_base_model ? super : cti_tables.last
         end
+
+        private
+
+        # If calling set_dataset manually, make sure to set the dataset
+        # row proc to one that handles inheritance correctly.
+        def set_dataset_row_proc(ds)
+          ds.row_proc = @dataset.row_proc if @dataset
+        end
+
       end
 
       module InstanceMethods

data/lib/sequel/plugins/constraint_validations.rb

@@ -33,7 +33,11 @@ module Sequel
 
       # Automatically load the validation_helpers plugin to run the actual validations.
       def self.apply(model, opts={})
-        model.plugin :validation_helpers
+        model.instance_eval do
+          plugin :validation_helpers
+          @constraint_validations_table = DEFAULT_CONSTRAINT_VALIDATIONS_TABLE
+          @constraint_validation_options = {}
+        end
       end
 
       # Parse the constraint validations metadata from the database. Options:
@@ -41,9 +45,25 @@ module Sequel
       #                                  metadata table.  Should only be used if the table
       #                                  name was overridden when creating the constraint
       #                                  validations.
+      # :validation_options :: Override/augment the options stored in the database with the
+      #                        given options.  Keys should be validation type symbols (e.g.
+      #                        :presence) and values should be hashes of options specific
+      #                        to that validation type.
       def self.configure(model, opts={})
-        model.instance_variable_set(:@constraint_validations_table, opts[:constraint_validations_table] || DEFAULT_CONSTRAINT_VALIDATIONS_TABLE)
-        model.send(:parse_constraint_validations)
+        model.instance_eval do
+          if table = opts[:constraint_validations_table]
+            @constraint_validations_table = table
+          end
+          if vos = opts[:validation_options]
+            vos.each do |k, v|
+              if existing_options = @constraint_validation_options[k]       
+                v = existing_options.merge(v)
+              end
+              @constraint_validation_options[k] = v
+            end
+          end
+          parse_constraint_validations
+        end
       end
 
       module DatabaseMethods
@@ -58,10 +78,17 @@ module Sequel
         # is splatted to send to perform a validation via validation_helpers.
         attr_reader :constraint_validations
 
+        # A hash of reflections of constraint validations.  Keys are type name
+        # symbols.  Each value is an array of pairs, with the first element being
+        # the validation type symbol (e.g. :presence) and the second element being
+        # options for the validation.  If the validation takes an argument, it appears
+        # as the :argument entry in the validation option hash.
+        attr_reader :constraint_validation_reflections
+
         # The name of the table containing the constraint validations metadata.
         attr_reader :constraint_validations_table
 
-        Plugins.inherited_instance_variables(self, :@constraint_validations_table=>nil)
+        Plugins.inherited_instance_variables(self, :@constraint_validations_table=>nil, :@constraint_validation_options=>:hash_dup)
         Plugins.after_set_dataset(self, :parse_constraint_validations)
 
         private
@@ -78,7 +105,7 @@ module Sequel
           unless hash = Sequel.synchronize{db.constraint_validations}
             hash = {}
             db.from(constraint_validations_table).each do |r|
-              (hash[r[:table]] ||= []) << constraint_validation_array(r)
+              (hash[r[:table]] ||= []) << r
             end
             Sequel.synchronize{db.constraint_validations = hash}
           end
@@ -86,14 +113,16 @@ module Sequel
           if @dataset
             ds = @dataset.clone
             ds.quote_identifiers = false
-            table_name = ds.literal(model.table_name)
-            @constraint_validations = Sequel.synchronize{hash[table_name]} || []
+            table_name = ds.literal(ds.first_source_table)
+            reflections = {}
+            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
+            @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)
+        def constraint_validation_array(r, reflections)
           opts = {}
           opts[:message] = r[:message] if r[:message]
           opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
@@ -131,14 +160,27 @@ module Sequel
             column.to_sym
           end
 
+          if type_opts = @constraint_validation_options[type]
+            opts = opts.merge(type_opts)
+          end
+
+          reflection_opts = opts
           a = [:"validates_#{type}"]
+
           if arg
             a << arg
+            reflection_opts = reflection_opts.merge(:argument=>arg)
           end 
           a << column
           unless opts.empty?
             a << opts
           end
+
+          if column.is_a?(Array) && column.length == 1
+            column = column.first
+          end
+          (reflections[column] ||= []) << [type, reflection_opts]
+
           a
         end