sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/typecast_on_load.rb

@@ -1,6 +1,8 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # The TypecastOnLoad plugin exists because most of Sequel's database adapters don't
+    # The typecast_on_load plugin exists because most of Sequel's database adapters don't
     # have complete control over typecasting, and may return columns that aren't
     # typecast correctly (with correct being defined as how the model object
     # would typecast the same column values).
@@ -21,7 +23,7 @@ module Sequel
     module TypecastOnLoad
       # Call add_typecast_on_load_columns on the passed column arguments.
       def self.configure(model, *columns)
-        model.instance_eval do
+        model.instance_exec do
           @typecast_on_load_columns ||= []
           add_typecast_on_load_columns(*columns)
         end
@@ -39,7 +41,16 @@ module Sequel
         # Typecast values using #load_typecast when the values are retrieved
         # from the database.
         def call(values)
-          super.load_typecast
+          o = super.load_typecast
+          o.send(:_clear_changed_columns, :initialize)
+          o
+        end
+
+        # Freeze typecast on load columns when freezing model class.
+        def freeze
+          @typecast_on_load_columns.freeze
+
+          super
         end
 
         Plugins.inherited_instance_variables(self, :@typecast_on_load_columns=>:dup)
@@ -54,7 +65,6 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          changed_columns.clear
           self
         end
 

data/lib/sequel/plugins/unlimited_update.rb

@@ -1,14 +1,10 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The unlimited_update plugin is designed to work around a
     # MySQL warning in replicated environments, which occurs if
-    # you issue an UPDATE with a LIMIT clause.  No other
-    # database Sequel supports will create an UPDATE clause with
-    # a LIMIT, and in non-replicated MySQL environments, MySQL
-    # doesn't issue a warning.  Note that even in replicated
-    # environments the MySQL warning is harmless, as Sequel
-    # restricts an update to rows with a matching primary key,
-    # which should be unique.
+    # you issue an UPDATE with a LIMIT clause.
     #
     # Usage:
     #

data/lib/sequel/plugins/update_or_create.rb

@@ -1,20 +1,22 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # The update_or_create plugin adds a couple of methods that make it easier
+    # The update_or_create plugin adds methods that make it easier
     # to deal with objects which may or may not yet exist in the database.
     # The first method is update_or_create, which updates an object if it
     # exists in the database, or creates the object if it does not.
     #
-    # You can call create_or_update with a block:
+    # You can call update_or_create with a block:
     #
-    #   Album.update_or_create(:name=>'Hello') do |album|
+    #   Album.update_or_create(name: 'Hello') do |album|
     #     album.num_copies_sold = 1000
     #   end
     #
     # or provide two hashes, with the second one being the attributes
     # to set.
     #
-    #   Album.update_or_create({:name=>'Hello'}, {:num_copies_sold=>1000})
+    #   Album.update_or_create({name: 'Hello'}, num_copies_sold: 1000)
     #
     # In both cases, this will check the database to find the album with
     # the name "Hello". If such an album exists, it will be updated to set

data/lib/sequel/plugins/update_primary_key.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The update_primary_key plugin allows you to modify an object's
@@ -61,7 +63,7 @@ module Sequel
           if type == :update
             false
           else
-            super
+            super if defined?(super)
           end
         end
       end

data/lib/sequel/plugins/update_refresh.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The update_refresh plugin makes the model class refresh
@@ -25,16 +27,36 @@ module Sequel
     # +columns+ option. This can be a performance gain if it
     # would avoid pointlessly comparing many other columns.
     # Note that this option currently only has an effect if the
-    # dataset # supports RETURNING.
+    # dataset supports RETURNING.
     #
     #   # Only include the artist column in RETURNING
-    #   Album.plugin :update_refresh, :columns => :artist
+    #   Album.plugin :update_refresh, columns: :artist
     #
     #   # Only include the artist and title columns in RETURNING
-    #   Album.plugin :update_refresh, :columns => [ :artist, :title ]
-    #
+    #   Album.plugin :update_refresh, columns: [:artist, :title]
     module UpdateRefresh
+      # Set the specific columns to refresh, if the :columns option
+      # is provided.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          @update_refresh_columns = Array(opts[:columns]) || []
+        end
+      end
+
+      module ClassMethods
+        # The specific columns to refresh when updating, if UPDATE RETURNING is supported.
+        attr_reader :update_refresh_columns
+
+        # Freeze the update refresh columns when freezing the model class.
+        def freeze
+          @update_refresh_columns.freeze
+
+          super
+        end
+      end
+
       module InstanceMethods
+        # If the dataset does not support UPDATE RETURNING, then refresh after an update.
         def after_update
           super
           unless this.supports_returning?(:update)
@@ -44,6 +66,8 @@ module Sequel
 
         private
 
+        # If the dataset supports UPDATE RETURNING, use it to do the refresh in the same
+        # query as the update.
         def _update_without_checking(columns)
           ds = _update_dataset
           if ds.supports_returning?(:update)
@@ -59,17 +83,6 @@ module Sequel
           end
         end
       end
-
-      module ClassMethods
-        attr_reader :update_refresh_columns
-      end
-
-      def self.configure(model, opts=OPTS)
-        model.instance_eval do
-          @update_refresh_columns = Array(opts[:columns]) || []
-        end
-      end
-
     end
   end
 end

data/lib/sequel/plugins/uuid.rb

@@ -0,0 +1,70 @@
+# frozen-string-literal: true
+
+require 'securerandom'
+
+module Sequel
+  module Plugins
+    # The uuid plugin creates hooks that automatically create a uuid for every
+    # instance.
+    # 
+    # Usage:
+    #
+    #   # Uuid all model instances using +uuid+
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :uuid
+    #
+    #   # Uuid Album instances, with custom column name
+    #   Album.plugin :uuid, field: :my_uuid
+    module Uuid
+      # Configure the plugin by setting the available options.  Note that
+      # if this method is run more than once, previous settings are ignored,
+      # and it will just use the settings given or the default settings.  Options:
+      # :field :: The field to hold the uuid (default: :uuid)
+      # :force :: Whether to overwrite an existing uuid (default: false)
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          @uuid_field = opts[:field]||:uuid
+          @uuid_overwrite = opts[:force]||false
+        end
+      end
+
+      module ClassMethods
+        # The field to store the uuid
+        attr_reader :uuid_field
+        
+        # Whether to overwrite the create uuid if it already exists
+        def uuid_overwrite?
+          @uuid_overwrite
+        end
+        
+        Plugins.inherited_instance_variables(self, :@uuid_field=>nil, :@uuid_overwrite=>nil)
+      end
+
+      module InstanceMethods
+        # Set the uuid when creating
+        def before_validation
+          set_uuid if new?
+          super
+        end
+
+        private
+        
+        # Create a new UUID.  This method can be overridden to use a separate
+        # method for creating UUIDs.
+        def create_uuid
+          SecureRandom.uuid
+        end
+        
+        # If the object has accessor methods for the uuid field, and the uuid
+        # value is nil or overwriting it is allowed, set the uuid.
+        def set_uuid(uuid=create_uuid)
+          field = model.uuid_field
+          meth = :"#{field}="
+          if respond_to?(field) && respond_to?(meth) && (model.uuid_overwrite? || get_column_value(field).nil?)
+            set_column_value(meth, uuid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validate_associated.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The validates_associated plugin allows you to validate associated
@@ -14,6 +16,24 @@ module Sequel
     #
     #   # Make the Album class support validating associated objects
     #   Album.plugin :validate_associated
+    #
+    #   class Album
+    #     many_to_one :artist
+    #     many_to_many :tags
+    #
+    #     # Always validate associated artist when saving the album
+    #     def validate
+    #       super
+    #       if artist
+    #         validate_associated_object(model.association_reflection(:artist), artist)
+    #       end
+    #     end
+    #
+    #     # When saving after calling this method, validate the given tag as well.
+    #     def check_tag!(tag)
+    #       delay_validate_associated_object(model.association_reflection(:tags), tag)
+    #     end
+    #   end
     module ValidateAssociated
       # Depend on the instance_hooks plugin.
       def self.apply(mod)

data/lib/sequel/plugins/validation_class_methods.rb

@@ -1,6 +1,6 @@
-module Sequel
-  extension :blank
+# frozen-string-literal: true
 
+module Sequel
   module Plugins
     # Sequel's built-in validation_class_methods plugin adds backwards compatibility
     # for the legacy class-level validation methods (e.g. validates_presence_of :column).
@@ -9,7 +9,7 @@ module Sequel
     # as it is less complex and more flexible.  However, this plugin provides reflection
     # support, since it is class-level, while the instance-level validation_helpers
     # plugin does not.
-    # 
+    #
     # Usage:
     #
     #   # Add the validation class methods to all model subclasses (called before loading subclasses)
@@ -37,13 +37,26 @@ module Sequel
         # options.
         attr_reader :validation_reflections
 
+        # Freeze validation metadata when freezing model class.
+        def freeze
+          @validations.freeze.each_value(&:freeze)
+          @validation_reflections.freeze.each_value do |vs|
+            vs.freeze.each do |v|
+              v.freeze
+              v.last.freeze
+            end
+          end
+
+          super
+        end
+
         # The Generator class is used to generate validation definitions using 
         # the validates {} idiom.
         class Generator
           # Initializes a new generator.
           def initialize(receiver ,&block)
             @receiver = receiver
-            instance_eval(&block)
+            instance_exec(&block)
           end
       
           # Delegates method calls to the receiver by calling receiver.validates_xxx.
@@ -84,15 +97,16 @@ module Sequel
         #
         #   class MyClass < Sequel::Model
         #     validates do
-        #       length_of :name, :minimum => 6
-        #       length_of :password, :minimum => 8
+        #       length_of :name, minimum: 6
+        #       length_of :password, minimum: 8
         #     end
         #   end
         #
         # is equivalent to:
+        #
         #   class MyClass < Sequel::Model
-        #     validates_length_of :name, :minimum => 6
-        #     validates_length_of :password, :minimum => 8
+        #     validates_length_of :name, minimum: 6
+        #     validates_length_of :password, minimum: 8
         #   end
         def validates(&block)
           Generator.new(self, &block)
@@ -103,7 +117,7 @@ module Sequel
           validations.each do |att, procs|
             v = case att
             when Array
-              att.collect{|a| o.get_column_value(a)}
+              att.map{|a| o.get_column_value(a)}
             else
               o.get_column_value(att)
             end
@@ -174,16 +188,25 @@ module Sequel
         #                   Sequel will attempt to insert a NULL value into the database, instead of using the
         #                   database's default.
         # :allow_nil :: Whether to skip the validation if the value is nil.
-        # :if :: A symbol (indicating an instance_method) or proc (which is instance_evaled)
+        # :if :: A symbol (indicating an instance_method) or proc (which is used to define an instance method)
         #        skipping this validation if it returns nil or false.
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
-          blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+          blank_meth = db.method(:blank_object?).to_proc
+          i = opts[:if]
+          am = opts[:allow_missing]
+          an = opts[:allow_nil]
+          ab = opts[:allow_blank]
+          blk = if i || am || an || ab
+            if i.is_a?(Proc)
+              i = Plugins.def_sequel_method(self, "validation_class_methods_if", 0, &i)
+            end
+
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
-              next if ab && Array(v).all?(&:blank?)
+              next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
               block.call(o,a,v)
             end
@@ -259,7 +282,7 @@ module Sequel
               o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && v.size == i
             end
             if w = opts[:within]
-              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.send(w.respond_to?(:cover?) ? :cover? : :include?, v.size)
+              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.public_send(w.respond_to?(:cover?) ? :cover? : :include?, v.size)
             end
           end
         end
@@ -302,7 +325,7 @@ module Sequel
           reflect_validation(:presence, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) if v.blank? && v != false
+            o.errors.add(a, opts[:message]) if db.send(:blank_object?, v) && v != false
           end
         end
         
@@ -321,7 +344,7 @@ module Sequel
           reflect_validation(:inclusion, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) unless n.send(n.respond_to?(:cover?) ? :cover? : :include?, v)
+            o.errors.add(a, opts[:message]) unless n.public_send(n.respond_to?(:cover?) ? :cover? : :include?, v)
           end
         end
     
@@ -376,7 +399,7 @@ module Sequel
             a = Array(a)
             v = Array(v)
             next if v.empty? || !v.all?
-            ds = o.class.filter(a.zip(v))
+            ds = o.class.where(a.zip(v))
             num_dups = ds.count
             allow = if num_dups == 0
               # No unique value in the database
@@ -404,7 +427,7 @@ module Sequel
         # an empty hash is returned This method is useful when writing methods that
         # take an options hash as the last parameter.
         def extract_options!(array)
-          array.last.is_a?(Hash) ? array.pop : {}
+          array.last.is_a?(Hash) ? array.pop : OPTS
         end
 
         # Add the validation reflection to the class's validations.
@@ -419,8 +442,6 @@ module Sequel
           case i
           when Symbol
             o.get_column_value(i)
-          when Proc
-            o.instance_eval(&i)
           else
             raise(::Sequel::Error, "invalid value for :if validation option")
           end

data/lib/sequel/plugins/validation_contexts.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The validation_contexts plugin adds support for a validation_context method inside a validate
+    # method.  You pass in the validation context to use via the :validation_context option to
+    # Sequel::Model#save && Sequel::Model#valid?:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validation_contexts
+    #     def validate
+    #       super
+    #       errors.add(:status_id, 'not 1') if status_id != 1 && validation_context == :initial
+    #       errors.add(:status_id, 'not 2') if status_id != 2 && validation_context == :approve
+    #     end
+    #   end
+    #
+    #   Album.new(status_id: 1).valid?(validation_context: :initial) # => true
+    #   Album.new(status_id: 2).valid?(validation_context: :initial) # => false
+    #
+    #   Album.new(status_id: 1).valid?(validation_context: :approve) # => false
+    #   Album.new(status_id: 2).valid?(validation_context: :approve) # => true
+    #
+    # There is no validation context used by default, so validation_context will be
+    # +nil+ if one is not specified.  If you want to differentiate between creating new
+    # objects and updating existing objects, just use +new?+.
+    #
+    # Once this plugin is loaded into a model, after you freeze an instance
+    # of that model, you can no longer specify a validation context when
+    # validating the instance.
+    module ValidationContexts
+      module InstanceMethods 
+        # The validation context to use for the current validation.
+        # Set via the :validation_context option passed to save/valid?.
+        attr_reader :validation_context
+
+        private
+
+        # Set validation context before running validations
+        def _valid?(opts)
+          @validation_context = opts[:validation_context] if opts[:validation_context]
+          super
+        ensure
+          @validation_context = nil if @validation_context
+        end
+      end
+    end
+  end
+end