sequel 5.8.0 → 5.38.0

data/lib/sequel/model/base.rb

@@ -250,7 +250,7 @@ module Sequel
       #   Artist.create do |a|
       #     a.name = 'Jim'
       #   end # INSERT INTO artists (name) VALUES ('Jim')
-      def create(values = {}, &block)
+      def create(values = OPTS, &block)
         new(values, &block).save
       end
   
@@ -324,14 +324,14 @@ module Sequel
       # Any public methods in the dataset module will have class methods created that
       # call the method on the dataset, assuming that the class method is not already
       # defined.
-      def dataset_module(mod = nil)
+      def dataset_module(mod = nil, &block)
         if mod
-          raise Error, "can't provide both argument and block to Model.dataset_module" if block_given?
+          raise Error, "can't provide both argument and block to Model.dataset_module" if block
           dataset_extend(mod)
           mod
         else
           @dataset_module ||= dataset_module_class.new(self)
-          @dataset_module.module_eval(&Proc.new) if block_given?
+          @dataset_module.module_eval(&block) if block
           dataset_extend(@dataset_module)
           @dataset_module
         end
@@ -446,6 +446,13 @@ module Sequel
         super
       end
 
+      # Whether the model has a dataset.  True for most model classes,
+      # but can be false if the model class is an abstract model class
+      # designed for subclassing, such as Sequel::Model itself.
+      def has_dataset?
+        !@dataset.nil?
+      end
+
       # Clear the setter_methods cache when a module is included, as it
       # may contain setter methods.
       def include(*mods)
@@ -453,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.
       #
@@ -508,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.
       #
@@ -531,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)
@@ -540,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
@@ -633,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
 
@@ -672,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
@@ -758,9 +724,11 @@ module Sequel
 
       # Create a column accessor for a column with a method name that is hard to use in ruby code.
       def def_bad_column_accessor(column)
+        im = instance_methods
         overridable_methods_module.module_eval do
-          define_method(column){self[column]}
-          define_method("#{column}="){|v| self[column] = v}
+          meth = :"#{column}="
+          define_method(column){self[column]} unless im.include?(column)
+          define_method(meth){|v| self[column] = v} unless im.include?(meth)
         end
       end
   
@@ -772,7 +740,7 @@ module Sequel
         bad_columns.each{|x| def_bad_column_accessor(x)}
         im = instance_methods
         columns.each do |column|
-          meth = "#{column}="
+          meth = :"#{column}="
           overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__) unless im.include?(column)
           overridable_methods_module.module_eval("def #{meth}(v); self[:#{column}] = v end", __FILE__, __LINE__) unless im.include?(meth)
         end
@@ -789,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
@@ -845,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)
@@ -899,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
@@ -1055,12 +1070,12 @@ module Sequel
       #   Artist.new do |a|
       #     a.name = 'Bob'
       #   end
-      def initialize(values = {})
+      def initialize(values = OPTS)
         @values = {}
         @new = true
         @modified = true
         initialize_set(values)
-        _changed_columns.clear
+        _clear_changed_columns(:initialize)
         yield self if block_given?
       end
 
@@ -1096,16 +1111,33 @@ module Sequel
         eql?(obj)
       end
   
-      # If pk is not nil, true only if the objects have the same class and pk.
-      # If pk is nil, false.
+      # Case equality.  By default, checks equality of the primary key value, see
+      # pk_equal?.
       #
-      #   Artist[1] === Artist[1] # true
-      #   Artist.new === Artist.new # false
-      #   Artist[1].set(:name=>'Bob') == Artist[1] # => true
+      #   Artist[1] === Artist[1] # => true
+      #   Artist.new === Artist.new # => false
+      #   Artist[1].set(:name=>'Bob') === Artist[1] # => true
       def ===(obj)
-        pk.nil? ? false : (obj.class == model) && (obj.pk == pk)
+        case pkv = pk
+        when nil
+          return false
+        when Array
+          return false if pkv.any?(&:nil?)
+        end
+
+        (obj.class == model) && (obj.pk == pkv)
       end
-  
+
+      # If the receiver has a primary key value, returns true if the objects have
+      # the same class and primary key value.
+      # If the receiver's primary key value is nil or is an array containing
+      # nil, returns false.
+      #
+      #   Artist[1].pk_equal?(Artist[1]) # => true
+      #   Artist.new.pk_equal?(Artist.new) # => false
+      #   Artist[1].set(:name=>'Bob').pk_equal?(Artist[1]) # => true
+      alias pk_equal? ===
+
       # class is defined in Object, but it is also a keyword,
       # and since a lot of instance methods call class methods,
       # this alias makes it so you can use model instead of
@@ -1280,11 +1312,11 @@ module Sequel
       #     a.update(:name=>'A')
       #   end
       #
-      #  a = Artist[2]
-      #  Artist.db.transaction do
-      #    a.lock!('FOR NO KEY UPDATE')
-      #    a.update(:name=>'B')
-      #  end
+      #   a = Artist[2]
+      #   Artist.db.transaction do
+      #     a.lock!('FOR NO KEY UPDATE')
+      #     a.update(:name=>'B')
+      #   end
       def lock!(style=:update)
         _refresh(this.lock_style(style)) unless new?
         self
@@ -1408,9 +1440,9 @@ module Sequel
       # is valid and before hooks execute successfully. Fails if:
       #
       # * the record is not valid, or
-      # * before_save returns false, or
-      # * the record is new and before_create returns false, or
-      # * the record is not new and before_update returns false.
+      # * before_save calls cancel_action, or
+      # * the record is new and before_create calls cancel_action, or
+      # * the record is not new and before_update calls cancel_action.
       #
       # If +save+ fails and either raise_on_save_failure or the
       # :raise_on_failure option is true, it raises ValidationFailed
@@ -1432,8 +1464,8 @@ module Sequel
       def save(opts=OPTS)
         raise Sequel::Error, "can't save frozen object" if frozen?
         set_server(opts[:server]) if opts[:server] 
-        unless checked_save_failure(opts){_valid?(opts)}
-          raise(ValidationFailed.new(self)) if raise_on_failure?(opts)
+        unless _save_valid?(opts)
+          raise(validation_failed_error) if raise_on_failure?(opts)
           return
         end
         checked_save_failure(opts){checked_transaction(opts){_save(opts)}}
@@ -1491,7 +1523,7 @@ module Sequel
       #   # Sequel::Error raised
       def set_fields(hash, fields, opts=nil)
         opts = if opts
-          Hash[model.default_set_fields_options].merge!(opts)
+          model.default_set_fields_options.merge(opts)
         else
           model.default_set_fields_options
         end
@@ -1527,6 +1559,15 @@ module Sequel
         super
       end
   
+      # Skip all validation of the object on the next call to #save,
+      # including the running of validation hooks. This is designed for
+      # and should only be used in cases where #valid? is called before
+      # saving and the <tt>validate: false</tt> option cannot be passed to
+      # #save.
+      def skip_validation_on_next_save!
+        @skip_validation_on_next_save = true
+      end
+
       # Returns (naked) dataset that should return only this instance.
       #
       #   Artist[1].this
@@ -1544,8 +1585,8 @@ module Sequel
         update_restricted(hash, :default)
       end
   
-      # Update the instances values by calling +set_fields+ with the arguments, then
-      # saves any changes to the record.  Returns self.
+      # Update the instance's values by calling set_fields with the arguments, then
+      # calls save_changes.
       #
       #   artist.update_fields({name: 'Jim'}, [:name])
       #   # UPDATE artists SET name = 'Jim' WHERE (id = 1)
@@ -1591,6 +1632,13 @@ module Sequel
       def _changed_columns
         @changed_columns ||= []
       end
+
+      # Clear the changed columns. Reason is the reason for clearing
+      # the columns, and should be one of: :initialize, :refresh, :create
+      # or :update.
+      def _clear_changed_columns(_reason)
+        _changed_columns.clear
+      end
   
       # Do the deletion of the object's dataset, and check that the row
       # was actually deleted.
@@ -1676,12 +1724,13 @@ 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
       def _refresh(dataset)
         _refresh_set_values(_refresh_get(dataset) || raise(NoExistingObject, "Record not found"))
-        _changed_columns.clear
+        _clear_changed_columns(:refresh)
       end
 
       # Get the row of column data from the database.
@@ -1719,7 +1768,7 @@ module Sequel
               @this = nil
               @new = false
               @modified = false
-              pk ? _save_refresh : _changed_columns.clear
+              pk ? _save_refresh : _clear_changed_columns(:create)
               after_create
               true
             end
@@ -1730,14 +1779,12 @@ module Sequel
               before_update
               columns = opts[:columns]
               if columns.nil?
-                if opts[:changed]
-                  cc = changed_columns
-                  columns_updated = @values.reject{|k,v| !cc.include?(k)}
-                  cc.clear
+                columns_updated = if opts[:changed]
+                  _save_update_changed_colums_hash
                 else
-                  columns_updated = _save_update_all_columns_hash
-                  _changed_columns.clear
+                  _save_update_all_columns_hash
                 end
+                _clear_changed_columns(:update)
               else # update only the specified columns
                 columns = Array(columns)
                 columns_updated = @values.reject{|k, v| !columns.include?(k)}
@@ -1763,7 +1810,7 @@ module Sequel
       # can be overridden to avoid the refresh.
       def _save_refresh
         _save_set_values(_refresh_get(this.server?(:default)) || raise(NoExistingObject, "Record not found"))
-        _changed_columns.clear
+        _clear_changed_columns(:create)
       end
 
       # Set values to the provided hash.  Called after a create,
@@ -1785,6 +1832,27 @@ module Sequel
         v
       end
 
+      # Return a hash of values used when saving changed columns of an
+      # existing object.  Defaults to all of the objects current values
+      # that are recorded as modified.
+      def _save_update_changed_colums_hash
+        cc = changed_columns
+        @values.reject{|k,v| !cc.include?(k)}
+      end
+
+      # Validate the object if validating on save. Skips validation
+      # completely (including validation hooks) if
+      # skip_validation_on_save! has been called on the object,
+      # resetting the flag so that future saves will validate.
+      def _save_valid?(opts)
+        if @skip_validation_on_next_save
+          @skip_validation_on_next_save = false
+          return true
+        end
+
+        checked_save_failure(opts){_valid?(opts)}
+      end
+
       # Call _update with the given columns, if any are present.
       # Plugins can override this method in order to update with
       # additional columns, even when the column hash is initially empty.
@@ -1868,6 +1936,11 @@ module Sequel
         Errors
       end
 
+      # A HookFailed exception for the given message tied to the current instance.
+      def hook_failed_error(msg)
+        HookFailed.new(msg, self)
+      end
+  
       # Clone constructor -- freeze internal data structures if the original's
       # are frozen.
       def initialize_clone(other)
@@ -1917,9 +1990,9 @@ module Sequel
           "a hook failed"
         end
 
-        raise HookFailed.new(msg, self)
+        raise hook_failed_error(msg)
       end
-  
+
       # Get the ruby class or classes related to the given column's type.
       def schema_type_class(column)
         if (sch = db_schema[column]) && (type = sch[:type])
@@ -2012,6 +2085,11 @@ module Sequel
       def use_transaction?(opts = OPTS)
         opts.fetch(:transaction, use_transactions)
       end
+
+      # An ValidationFailed exception instance to raise for this instance.
+      def validation_failed_error
+        ValidationFailed.new(self)
+      end
     end
 
     # DatasetMethods contains methods that all model datasets have.
@@ -2160,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