sequel 5.39.0 → 5.44.0

data/lib/sequel/extensions/blank.rb

@@ -6,6 +6,14 @@
 #
 #   Sequel.extension :blank
 
+[FalseClass, Object, NilClass, Numeric, String, TrueClass].each do |klass|
+  # :nocov:
+  if klass.method_defined?(:blank?)
+    klass.send(:alias_method, :blank?, :blank?)
+  end
+  # :nocov:
+end
+
 class FalseClass
   # false is always blank
   def blank?

data/lib/sequel/extensions/date_arithmetic.rb

@@ -8,9 +8,10 @@
 #   DB.extension :date_arithmetic
 #
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
-# to return Sequel expressions:
+# to return Sequel expressions (this example shows the only supported
+# keys for the second argument):
 #
-#   add = Sequel.date_add(:date_column, years: 1, months: 2, days: 3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
 #   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
@@ -49,14 +50,12 @@ module Sequel
       # Options:
       # :cast :: Cast to the specified type instead of the default if casting
       def date_sub(expr, interval, opts=OPTS)
-        interval = if interval.is_a?(Hash)
-          h = {}
-          interval.each{|k,v| h[k] = -v unless v.nil?}
-          h
-        else
-          -interval
+        if defined?(ActiveSupport::Duration) && interval.is_a?(ActiveSupport::Duration)
+          interval = interval.parts
         end
-        DateAdd.new(expr, interval, opts)
+        parts = {}
+        interval.each{|k,v| parts[k] = -v unless v.nil?}
+        DateAdd.new(expr, parts, opts)
       end
     end
 
@@ -113,12 +112,12 @@ module Sequel
             end
           when :mssql, :h2, :access, :sqlanywhere
             units = case db_type
-            when :mssql, :sqlanywhere
-              MSSQL_DURATION_UNITS
             when :h2
               H2_DURATION_UNITS
             when :access
               ACCESS_DURATION_UNITS
+            else
+              MSSQL_DURATION_UNITS
             end
             each_valid_interval_unit(h, units) do |value, sql_unit|
               expr = Sequel.function(:DATEADD, sql_unit, value, expr)
@@ -186,22 +185,35 @@ module Sequel
       # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
       def initialize(expr, interval, opts=OPTS)
         @expr = expr
-        @interval = if interval.is_a?(Hash)
-          interval.each_value do |v|
-             # Attempt to prevent SQL injection by users who pass untrusted strings
-             # as interval values. 
-             if v.is_a?(String) && !v.is_a?(LiteralString)
-               raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
-             end
+
+        h = Hash.new(0)
+        interval = interval.parts unless interval.is_a?(Hash)
+        interval.each do |unit, value|
+          # skip nil values
+          next unless value
+
+          # Convert weeks to days, as ActiveSupport::Duration can use weeks,
+          # but the database-specific literalizers only support days.
+          if unit == :weeks
+            unit = :days
+            value *= 7
           end
-          Hash[interval]
-        else
-          h = Hash.new(0)
-          interval.parts.each{|unit, value| h[unit] += value}
-          Hash[h]
+
+          unless DatasetMethods::DURATION_UNITS.include?(unit)
+            raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
+          end
+
+          # Attempt to prevent SQL injection by users who pass untrusted strings
+          # as interval values. It doesn't make sense to support literal strings,
+          # due to the numeric adding below.
+          if value.is_a?(String)
+            raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
+          end
+
+          h[unit] += value
         end
 
-        @interval.freeze
+        @interval = Hash[h].freeze
         @cast_type = opts[:cast] if opts[:cast]
         freeze
       end

data/lib/sequel/extensions/eval_inspect.rb

@@ -55,6 +55,8 @@ module Sequel
 
   module SQL
     class Expression
+      alias inspect inspect
+
       # Attempt to produce a string suitable for eval, such that:
       #
       #   eval(obj.inspect) == obj

data/lib/sequel/extensions/inflector.rb

@@ -105,6 +105,14 @@ class String
     yield Inflections if block_given?
     Inflections
   end
+  
+  %w'classify constantize dasherize demodulize foreign_key humanize pluralize singularize tableize underscore'.each do |m|
+    # :nocov:
+    if method_defined?(m)
+      alias_method(m, m)
+    end
+    # :nocov:
+  end
 
   # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
   # is set to :lower then camelize produces lowerCamelCase.

data/lib/sequel/extensions/migration.rb

@@ -68,7 +68,9 @@ module Sequel
       # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    # :nocov:
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)

data/lib/sequel/extensions/named_timezones.rb

@@ -84,9 +84,9 @@ module Sequel
       def convert_output_time_other(v, output_timezone)
         Time.at(v.to_i, :in => output_timezone)
       end
-    else
       # :nodoc:
       # :nocov:
+    else
       def convert_input_time_other(v, input_timezone)
         local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
         Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
@@ -105,6 +105,8 @@ module Sequel
           Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
         end
       end
+      # :nodoc:
+      # :nocov:
     end
 
     # Handle both TZInfo 1 and TZInfo 2
@@ -142,6 +144,8 @@ module Sequel
         # Convert timezone offset from UTC to the offset for the output_timezone
         (v - local_offset).new_offset(local_offset)
       end
+      # :nodoc:
+      # :nocov:
     end
     
     # Returns TZInfo::Timezone instance if given a String.

data/lib/sequel/extensions/pg_array.rb

@@ -213,6 +213,7 @@ module Sequel
             scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
             define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
             private meth
+            alias_method(meth, meth)
           end
 
           @schema_type_classes[:"#{type}_array"] = PGArray

data/lib/sequel/extensions/pg_enum.rb

@@ -42,7 +42,7 @@
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of enum types, load the pg_array extension before the
-# pg_interval extension:
+# pg_enum extension:
 #
 #   DB.extension :pg_array, :pg_enum
 #

data/lib/sequel/extensions/pg_interval.rb

@@ -34,6 +34,13 @@
 
 require 'active_support/duration'
 
+# :nocov:
+begin
+  require 'active_support/version'
+rescue LoadError
+end
+# :nocov:
+
 module Sequel
   module Postgres
     module IntervalDatabaseMethods
@@ -61,34 +68,47 @@ module Sequel
 
       # Creates callable objects that convert strings into ActiveSupport::Duration instances.
       class Parser
+        # Whether ActiveSupport::Duration.new takes parts as array instead of hash
+        USE_PARTS_ARRAY = !defined?(ActiveSupport::VERSION::STRING) || ActiveSupport::VERSION::STRING < '5.1'
+
+        if defined?(ActiveSupport::Duration::SECONDS_PER_MONTH)
+          SECONDS_PER_MONTH = ActiveSupport::Duration::SECONDS_PER_MONTH
+          SECONDS_PER_YEAR = ActiveSupport::Duration::SECONDS_PER_YEAR
+        # :nocov:
+        else
+          SECONDS_PER_MONTH = 2592000
+          SECONDS_PER_YEAR = 31557600
+        # :nocov:
+        end
+
         # Parse the interval input string into an ActiveSupport::Duration instance.
         def call(string)
           raise(InvalidValue, "invalid or unhandled interval format: #{string.inspect}") unless matches = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/.match(string)
 
           value = 0
-          parts = []
+          parts = {}
 
           if v = matches[1]
             v = v.to_i
-            value += 31557600 * v
-            parts << [:years, v]
+            value += SECONDS_PER_YEAR * v
+            parts[:years] = v
           end
           if v = matches[2]
             v = v.to_i
-            value += 2592000 * v
-            parts << [:months, v]
+            value += SECONDS_PER_MONTH * v
+            parts[:months] = v
           end
           if v = matches[3]
             v = v.to_i
             value += 86400 * v
-            parts << [:days, v]
+            parts[:days] = v
           end
           if matches[5]
             seconds = matches[5].to_i * 3600 + matches[6].to_i * 60
             seconds += matches[8] ? matches[7].to_f : matches[7].to_i
             seconds *= -1 if matches[4] == '-'
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
           elsif matches[9] || matches[10] || matches[11]
             seconds = 0
             if v = matches[9]
@@ -101,8 +121,14 @@ module Sequel
               seconds += matches[12] ? v.to_f : v.to_i
             end
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
+          end
+
+          # :nocov:
+          if USE_PARTS_ARRAY
+            parts = parts.to_a
           end
+          # :nocov:
 
           ActiveSupport::Duration.new(value, parts)
         end

data/lib/sequel/extensions/pg_row.rb

@@ -482,6 +482,7 @@ module Sequel
               row_type(db_type, v)
             end
             private meth
+            alias_method(meth, meth)
           end
 
           nil

data/lib/sequel/extensions/query.rb

@@ -74,7 +74,9 @@ module Sequel
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self
       end
+      # :nocov:
       ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      # :nocov:
     end
   end
 

data/lib/sequel/model/associations.rb

@@ -263,7 +263,9 @@ module Sequel
         # yielding each row to the block.
         def eager_load_results(eo, &block)
           rows = eo[:rows]
-          initialize_association_cache(rows) unless eo[:initialize_rows] == false
+          unless eo[:initialize_rows] == false
+            Sequel.synchronize_with(eo[:mutex]){initialize_association_cache(rows)}
+          end
           if eo[:id_map]
             ids = eo[:id_map].keys
             return ids if ids.empty?
@@ -311,7 +313,8 @@ module Sequel
             objects = loader.all(ids)
           end
 
-          objects.each(&block)
+          Sequel.synchronize_with(eo[:mutex]){objects.each(&block)}
+
           if strategy == :ruby
             apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
           end
@@ -1929,7 +1932,22 @@ module Sequel
         # can be easily overridden in the class itself while allowing for
         # super to be called.
         def association_module_def(name, opts=OPTS, &block)
-          association_module(opts).send(:define_method, name, &block)
+          mod = association_module(opts)
+          mod.send(:define_method, name, &block)
+          mod.send(:alias_method, name, name)
+        end
+
+        # Add a method to the module included in the class, so the method
+        # can be easily overridden in the class itself while allowing for
+        # super to be called.  This method allows passing keywords through
+        # the defined methods.
+        def association_module_delegate_def(name, opts, &block)
+          mod = association_module(opts)
+          mod.send(:define_method, name, &block)
+          # :nocov:
+          mod.send(:ruby2_keywords, name) if mod.respond_to?(:ruby2_keywords, true)
+          # :nocov:
+          mod.send(:alias_method, name, name)
         end
       
         # Add a private method to the module included in the class.
@@ -1981,17 +1999,17 @@ module Sequel
 
           if adder = opts[:adder]
             association_module_private_def(opts[:_add_method], opts, &adder)
-            association_module_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
+            association_module_delegate_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
           end
 
           if remover = opts[:remover]
             association_module_private_def(opts[:_remove_method], opts, &remover)
-            association_module_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
+            association_module_delegate_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
           end
 
           if clearer = opts[:clearer]
             association_module_private_def(opts[:_remove_all_method], opts, &clearer)
-            association_module_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
+            association_module_delegate_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
           end
         end
         
@@ -2423,6 +2441,9 @@ module Sequel
           run_association_callbacks(opts, :after_add, o)
           o
         end
+        # :nocov:
+        ruby2_keywords(:add_associated_object) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Add/Set the current object to/as the given object's reciprocal association.
         def add_reciprocal_object(opts, o)
@@ -2565,6 +2586,9 @@ module Sequel
           associations[opts[:name]] = []
           ret
         end
+        # :nocov:
+        ruby2_keywords(:remove_all_associated_objects) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Remove the given associated object from the given association
         def remove_associated_object(opts, o, *args)
@@ -2586,6 +2610,9 @@ module Sequel
           run_association_callbacks(opts, :after_remove, o)
           o
         end
+        # :nocov:
+        ruby2_keywords(:remove_associated_object) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Check that the object from the associated table specified by the primary key
         # is currently associated to the receiver.  If it is associated, return the object, otherwise
@@ -3350,15 +3377,30 @@ module Sequel
           egl.dup
         end
 
-        # Eagerly load all specified associations 
+        # Eagerly load all specified associations.
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
+
+          # Reflections for all associations to eager load
+          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+
+          perform_eager_loads(prepare_eager_load(a, reflections, eager_assoc))
+
+          reflections.each do |r|
+            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
+          end 
+
+          nil
+        end
+
+        # Prepare a hash loaders and eager options which will be used to implement the eager loading.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          eager_load_data = {}
+
           # Key is foreign/primary key name symbol.
           # Value is hash with keys being foreign/primary key values (generally integers)
           # and values being an array of current model objects with that specific foreign/primary key
           key_hash = {}
-          # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
           # Populate the key_hash entry for each association being eagerly loaded
           reflections.each do |r|
@@ -3389,7 +3431,6 @@ module Sequel
               id_map = nil
             end
           
-            loader = r[:eager_loader]
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
@@ -3397,9 +3438,23 @@ module Sequel
             elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
               eager_block, associations = pr_assoc
             end
-            loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map)
-            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
-          end 
+
+            eager_load_data[r[:eager_loader]] = {:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map}
+          end
+
+          eager_load_data
+        end
+
+        # Using the hash of loaders and eager options, perform the eager loading.
+        def perform_eager_loads(eager_load_data)
+          eager_load_data.map do |loader, eo|
+            perform_eager_load(loader, eo)
+          end
+        end
+
+        # Perform eager loading for a single association using the loader and eager options.
+        def perform_eager_load(loader, eo)
+          loader.call(eo)
         end
 
         # Return a subquery expression for filering by a many_to_many association