sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/column_conflicts.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The column_conflicts plugin overrides Model#get_column_value and #set_column_value
@@ -27,11 +29,16 @@ module Sequel
     #   # Make the Album class handle column conflicts automatically
     #   Album.plugin :column_conflicts
     module ColumnConflicts
-      # Check for column conflicts on the current model if the model has a dataset.
-      def self.configure(model)
-        model.instance_eval do
+      def self.apply(model)
+        model.instance_exec do
           @get_column_conflicts = {}
           @set_column_conflicts = {}
+        end
+      end
+
+      # Check for column conflicts on the current model if the model has a dataset.
+      def self.configure(model)
+        model.instance_exec do
           check_column_conflicts if @dataset
         end
       end
@@ -58,6 +65,14 @@ module Sequel
           columns.find_all{|c| mod.method_defined?("#{c}=")}.each{|c| set_column_conflict!(c)}
         end
 
+        # Freeze column conflict information when freezing model class.
+        def freeze
+          @get_column_conflicts.freeze
+          @set_column_conflicts.freeze
+
+          super
+        end
+
         # Set the given column as one with a getter method conflict.
         def get_column_conflict!(column)
           @get_column_conflicts[column.to_sym] = @get_column_conflicts[column.to_s] = column.to_sym

data/lib/sequel/plugins/column_select.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The column_select plugin changes the default selection for a
@@ -26,7 +28,7 @@ module Sequel
       # Modify the current model's dataset selection, if the model
       # has a dataset.
       def self.configure(model)
-        model.instance_eval do
+        model.instance_exec do
           self.dataset = dataset if @dataset
         end
       end
@@ -39,15 +41,17 @@ module Sequel
         # qualifying them with table's name.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+          unless ds.opts[:select]
             if db.supports_schema_parsing?
-              cols = check_non_connection_error{db.schema(ds)}
+              cols = check_non_connection_error(false){db.schema(ds)}
               if cols
                 cols = cols.map{|c, _| c}
               end
             end
-            cols ||= check_non_connection_error{ds.columns}
-            ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+
+            if cols ||= check_non_connection_error(false){ds.columns}
+              ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+            end
           end
           ds
         end

data/lib/sequel/plugins/columns_updated.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The columns_updated plugin stores the columns hash used in the
+    # UPDATE query when saving the instance, and makes it available
+    # in the after_update and after_save hooks via the +columns_updated+
+    # accessor.  The data is cleared before returning from +save+.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses store the columns hash used for updating
+    #   Sequel::Model.plugin :columns_updated
+    #
+    #   # Make the Album class store the columns hash used for updating
+    #   Album.plugin :columns_updated
+    module ColumnsUpdated
+      module InstanceMethods
+        private
+
+        # The hash used for updating records.  This should only be called
+        # in the after_update and after_save hooks.
+        attr_reader :columns_updated
+
+        # Store the hash used for updating the record, so it can be accessed
+        # in the after_hooks.
+        def _update_columns(columns_updated)
+          @columns_updated = columns_updated
+          super
+        end
+
+        # Unset the updated columns hash before returning from save.
+        def _save(opts)
+          super
+        ensure
+          @columns_updated = nil
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/composition.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The composition plugin allows you to easily define a virtual
@@ -10,7 +12,7 @@ module Sequel
     # This can be handled with:
     #
     #   Album.plugin :composition
-    #   Album.composition :date, :mapping=>[:year, :month, :day]
+    #   Album.composition :date, mapping: [:year, :month, :day]
     #
     # With the :mapping option, you can provide a :class option
     # that gives the class to use, but if that is not provided, it
@@ -30,9 +32,10 @@ module Sequel
     #
     # The :mapping option is just a shortcut that works in particular
     # cases.  To handle any case, you can define a custom :composer
-    # and :decomposer procs.  The :composer proc will be instance_evaled
-    # the first time the getter is called, and the :decomposer proc
-    # will be instance_evaled before saving.  The above example could
+    # and :decomposer procs.  The :composer and :decomposer procs will
+    # be used to define instance methods.  The :composer will be called
+    # the first time the getter is called, and the :decomposer 
+    # will be called before saving.  The above example could
     # also be implemented as:
     #
     #   Album.composition :date,
@@ -56,7 +59,10 @@ module Sequel
     module Composition
       # Define the necessary class instance variables.
       def self.apply(model)
-        model.instance_eval{@compositions = {}}
+        model.instance_exec do
+          @compositions = {}
+          include(@composition_module ||= Module.new)
+        end
       end
 
       module ClassMethods
@@ -64,18 +70,14 @@ module Sequel
         # hash values.
         attr_reader :compositions
         
-        # A module included in the class holding the composition
-        # getter and setter methods.
-        attr_reader :composition_module
-        
         # Define a composition for this model, with name being the name of the composition.
         # You must provide either a :mapping option or both the :composer and :decomposer options. 
         #
         # Options:
         # :class :: if using the :mapping option, the class to use, as a Class, String or Symbol.
-        # :composer :: A proc that is instance evaled when the composition getter method is called
+        # :composer :: A proc used to define the method that the composition getter method will call 
         #              to create the composition.
-        # :decomposer :: A proc that is instance evaled before saving the model object,
+        # :decomposer :: A proc used to define the method called before saving the model object,
         #                if the composition object exists, which sets the columns in the model object
         #                based on the value of the composition object.
         # :mapping :: An array where each element is either a symbol or an array of two symbols.
@@ -84,12 +86,12 @@ module Sequel
         #             represents the getter method in the composition object. Example:
         #                 # Uses columns year, month, and day in the current model
         #                 # Uses year, month, and day methods in the composition object
-        #                 {:mapping=>[:year, :month, :day]}
+        #                 {mapping: [:year, :month, :day]}
         #                 # Uses columns year, month, and day in the current model
         #                 # Uses y, m, and d methods in the composition object where
         #                 # for example y in the composition object represents year
         #                 # in the model object.
-        #                 {:mapping=>[[:year, :y], [:month, :m], [:day, :d]]}
+        #                 {mapping: [[:year, :y], [:month, :m], [:day, :d]]}
         def composition(name, opts=OPTS)
           opts = opts.dup
           compositions[name] = opts
@@ -113,9 +115,9 @@ module Sequel
               setters = setter_meths.zip(cov_methods)
               opts[:decomposer] = proc do
                 if (o = compositions[name]).nil?
-                  setter_meths.each{|sm| get_column_value(sm, nil)}
+                  setter_meths.each{|sm| set_column_value(sm, nil)}
                 else
-                  setters.each{|sm, cm| get_column_value(sm, o.send(cm))}
+                  setters.each{|sm, cm| set_column_value(sm, o.public_send(cm))}
                 end
               end
             end
@@ -128,16 +130,17 @@ module Sequel
         
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts=OPTS)
-          include(@composition_module ||= Module.new) unless composition_module
-          composer = opts[:composer]
-          composition_module.class_eval do
+          composer_meth = opts[:composer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_composer", 0, &opts[:composer])
+          opts[:decomposer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_decomposer", 0, &opts[:decomposer])
+          @composition_module.class_eval do
             define_method(name) do 
               if compositions.has_key?(name)
                 compositions[name]
               elsif frozen?
-                instance_eval(&composer)
+                # composer_meth is private
+                send(composer_meth)
               else
-                compositions[name] = instance_eval(&composer)
+                compositions[name] = send(composer_meth)
               end
             end
             define_method("#{name}=") do |v|
@@ -146,6 +149,14 @@ module Sequel
             end
           end
         end
+
+        # Freeze composition information when freezing model class.
+        def freeze
+          compositions.freeze.each_value(&:freeze)
+          @composition_module.freeze
+
+          super
+        end
       end
 
       module InstanceMethods
@@ -160,15 +171,16 @@ module Sequel
           super
         end
 
-        private
-
         # For each composition, set the columns in the model class based
         # on the composition object.
-        def _before_validation
-          @compositions.keys.each{|n| instance_eval(&model.compositions[n][:decomposer])} if @compositions
+        def before_validation
+          # decomposer_method is private
+          @compositions.keys.each{|n| send(model.compositions[n][:decomposer_method])} if @compositions
           super
         end
         
+        private
+
         # Clear the cached compositions when manually refreshing.
         def _refresh_set_values(hash)
           @compositions.clear if @compositions

data/lib/sequel/plugins/constraint_validations.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The constraint_validations plugin is designed to be used with databases
@@ -17,7 +19,7 @@ module Sequel
     #
     # Then when you went to save an album that uses this plugin:
     #
-    #   Album.create(:name=>'abc')
+    #   Album.create(name: 'abc')
     #   # raises Sequel::ValidationFailed: name is shorter than 5 characters
     # 
     # Usage:
@@ -31,9 +33,13 @@ module Sequel
       # The default constraint validation metadata table name.
       DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
 
+      # Mapping of operator names in table to ruby operators
+      OPERATOR_MAP = {:str_lt => :<, :str_lte => :<=, :str_gt => :>, :str_gte => :>=,
+                      :int_lt => :<, :int_lte => :<=, :int_gt => :>, :int_gte => :>=}.freeze
+
       # Automatically load the validation_helpers plugin to run the actual validations.
       def self.apply(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           plugin :validation_helpers
           @constraint_validations_table = DEFAULT_CONSTRAINT_VALIDATIONS_TABLE
           @constraint_validation_options = {}
@@ -50,7 +56,7 @@ module Sequel
       #                        :presence) and values should be hashes of options specific
       #                        to that validation type.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           if table = opts[:constraint_validations_table]
             @constraint_validations_table = table
           end
@@ -66,13 +72,6 @@ module Sequel
         end
       end
 
-      module DatabaseMethods
-        # A hash of validation method call metadata for all tables in the database.
-        # The hash is keyed by table name string and contains arrays of validation
-        # method call arrays.
-        attr_accessor :constraint_validations
-      end
-
       module ClassMethods
         # An array of validation method call arrays.  Each array is an array that
         # is splatted to send to perform a validation via validation_helpers.
@@ -91,6 +90,18 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@constraint_validations_table=>nil, :@constraint_validation_options=>:hash_dup)
         Plugins.after_set_dataset(self, :parse_constraint_validations)
 
+        # Freeze constraint validations data when freezing model class.
+        def freeze
+          @constraint_validations.freeze.each(&:freeze)
+          @constraint_validation_reflections.freeze.each_value do |v|
+            v.freeze
+            v.each(&:freeze)
+          end
+          @constraint_validation_options.freeze.each_value(&:freeze)
+
+          super
+        end
+
         private
 
         # If the database has not already parsed constraint validation
@@ -100,7 +111,7 @@ module Sequel
         # If this model has associated dataset, use the model's table name
         # to get the validations for just this model.
         def parse_constraint_validations
-          db.extend(DatabaseMethods)
+          db.extension(:_model_constraint_validations)
 
           unless hash = Sequel.synchronize{db.constraint_validations}
             hash = {}
@@ -111,8 +122,7 @@ module Sequel
           end
 
           if @dataset
-            ds = @dataset.clone
-            ds.quote_identifiers = false
+            ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
             @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
@@ -152,6 +162,10 @@ module Sequel
           when :includes_int_range
             arg = constraint_validation_int_range(arg)
             type = :includes
+          when *OPERATOR_MAP.keys
+            arg = arg.to_i if type.to_s =~ /\Aint_/
+            operator = OPERATOR_MAP[type]
+            type = :operator
           end
 
           column = if type == :unique
@@ -161,16 +175,22 @@ module Sequel
           end
 
           if type_opts = @constraint_validation_options[type]
-            opts = opts.merge(type_opts)
+            opts.merge!(type_opts)
           end
 
-          reflection_opts = opts
+          reflection_opts = opts.dup
           a = [:"validates_#{type}"]
 
+          if operator
+            a << operator
+            reflection_opts[:operator] = operator
+          end
+
           if arg
             a << arg
-            reflection_opts = reflection_opts.merge(:argument=>arg)
+            reflection_opts[:argument] = arg
           end 
+
           a << column
           unless opts.empty?
             a << opts
@@ -220,6 +240,7 @@ module Sequel
         def validate
           super
           model.constraint_validations.each do |v|
+            # Allow calling private validation methods
             send(*v)
           end
         end

data/lib/sequel/plugins/csv_serializer.rb

@@ -1,40 +1,35 @@
-if RUBY_VERSION < "1.9"
-  # :nocov:
-  require 'fastercsv'
-  # :nocov:
-else
-  require 'csv'
-end
+# frozen-string-literal: true
+
+require 'csv'
 
 module Sequel
   module Plugins
     # csv_serializer handles serializing entire Sequel::Model objects to CSV,
     # as well as support for deserializing CSV directly into Sequel::Model
-    # objects.  It requires either the csv standard library when usnig ruby 1.9+,
-    # or the fastercsv gem when using ruby 1.8.
+    # objects.  It requires the csv standard library.
     #
     # Basic Example:
     #
     #   album = Album[1]
-    #   album.to_csv(:write_headers=>true)
+    #   album.to_csv(write_headers: true)
     #   # => "id,name,artist_id\n1,RF,2\n"
     #
     # You can provide options to control the CSV output:
     #
-    #   album.to_csv(:only=>:name)
-    #   album.to_csv(:except=>[:id, :artist_id])
+    #   album.to_csv(only: :name)
+    #   album.to_csv(except: [:id, :artist_id])
     #   # => "RF\n"
     #
     # +to_csv+ also exists as a class and dataset method, both of which return
     # all objects in the dataset:
     #
     #   Album.to_csv
-    #   Album.filter(:artist_id=>1).to_csv
+    #   Album.where(artist_id: 1).to_csv
     #
-    # If you have an existing array of model instance you want to convert to
+    # If you have an existing array of model instances you want to convert to
     # CSV, you can call the class to_csv method with the :array option:
     #
-    #   Album.to_csv(:array=>[Album[1], Album[2]])
+    #   Album.to_csv(array: [Album[1], Album[2]])
     #
     # In addition to creating CSV, this plugin also enables Sequel::Model
     # classes to create instances directly from CSV using the from_csv class
@@ -46,7 +41,7 @@ module Sequel
     # The array_from_csv class method exists to parse arrays of model instances
     # from CSV:
     #
-    #   csv = Album.filter(:artist_id=>1).to_csv
+    #   csv = Album.where(artist_id: 1).to_csv
     #   albums = Album.array_from_csv(csv)
     #
     # These do not necessarily round trip, since doing so would let users
@@ -54,7 +49,7 @@ module Sequel
     # call set with the values in the hash.  If you want to specify the allowed
     # fields, you can use the :headers option.
     #
-    #   Album.from_csv(album.to_csv, :headers=>%w'id name')
+    #   Album.from_csv(album.to_csv, headers: %w'id name')
     #
     # If you want to update an existing instance, you can use the from_csv
     # instance method:
@@ -70,41 +65,67 @@ module Sequel
     #   # Add CSV output capability to Album class instances
     #   Album.plugin :csv_serializer
     module CsvSerializer
-      CSV = Object.const_defined?(:CSV) ? ::CSV : ::FasterCSV
-
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values
-      def self.configure(model, opts = {})
-        model.instance_eval do
-          @csv_serializer_opts = (@csv_serializer_opts || {}).merge(opts)
+      def self.configure(model, opts = OPTS)
+        model.instance_exec do
+          @csv_serializer_opts = (@csv_serializer_opts || OPTS).merge(opts)
         end
       end
 
+      # Avoid keyword argument separation warnings on Ruby 2.7, while still
+      # being compatible with 1.9.
+      if RUBY_VERSION >= "2.0"
+        instance_eval(<<-END, __FILE__, __LINE__+1)
+          def self.csv_call(*args, opts, &block)
+            CSV.send(*args, **opts, &block)
+          end
+        END
+      else
+        # :nocov:
+        # :nodoc:
+        def self.csv_call(*args, opts, &block)
+          CSV.send(*args, opts, &block)
+        end
+        # :nodoc:
+        # :nocov:
+      end
+
       module ClassMethods
         # The default opts to use when serializing model objects to CSV
         attr_reader :csv_serializer_opts
 
         # Attempt to parse an array of instances from the given CSV string
-        def array_from_csv(csv, opts = {})
-          CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
+        def array_from_csv(csv, opts = OPTS)
+          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
           end
         end
 
+        # Freeze csv serializier opts when freezing model class
+        def freeze
+          @csv_serializer_opts.freeze.each_value do |v|
+            v.freeze if v.is_a?(Array) || v.is_a?(Hash)
+          end
+
+          super
+        end
+
         # Attempt to parse a single instance from the given CSV string
-        def from_csv(csv, opts = {})
+        def from_csv(csv, opts = OPTS)
           new.from_csv(csv, opts)
         end
 
         # Convert the options hash to one that can be passed to CSV.
         def process_csv_serializer_opts(opts)
-          opts = (csv_serializer_opts || {}).merge(opts)
+          opts = (csv_serializer_opts || OPTS).merge(opts)
           opts_cols = opts.delete(:columns)
           opts_include = opts.delete(:include)
           opts_except = opts.delete(:except)
-          opts[:headers] ||= Array(opts.delete(:only) || opts_cols || columns) + Array(opts_include) - Array(opts_except)
+          only = opts.delete(:only) 
+          opts[:headers] ||= Array(only || opts_cols || columns) + Array(opts_include) - Array(opts_except)
           opts
         end
 
@@ -125,8 +146,8 @@ module Sequel
         #
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
-        def from_csv(csv, opts = {})
-          row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
+        def from_csv(csv, opts = OPTS)
+          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -140,11 +161,12 @@ module Sequel
         #          output, ignoring all other columns
         # :include :: Symbol or Array of Symbols specifying non-column
         #             attributes to include in the CSV output.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts(opts)
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
-            csv << opts[:headers].map{|k| send(k)}
+          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+            csv << headers.map{|k| public_send(k)}
           end
         end
       end
@@ -157,13 +179,14 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided, calls #all
         #           on the receiver to get the array.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
           items = opts.delete(:array) || self
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
+          CsvSerializer.csv_call(:generate, opts) do |csv|
             items.each do |object|
-              csv << opts[:headers].map{|header| object[header]}
+              csv << headers.map{|header| object.public_send(header)}
             end
           end
         end