sequel 5.107.0 → 5.109.0

data/lib/sequel/plugins/validation_helpers.rb

@@ -39,7 +39,7 @@ module Sequel
     # :skip_invalid :: Do not try to validate columns that are already invalid.
     #
     # The default validation options for all models can be modified by
-    # overridding the Model#default_validation_helpers_options private method.
+    # overriding the Model#default_validation_helpers_options private method.
     # By changing the default options, you can setup internationalization of the
     # error messages.  For example, you would modify the default options:
     #

data/lib/sequel/plugins/xml_serializer.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+# SEQUEL6: Remove
+
 require 'nokogiri'
 
 module Sequel

data/lib/sequel/sql.rb

@@ -371,7 +371,7 @@ module Sequel
         SQL::CaseExpression.new(*args)
       end
 
-      # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
+      # Cast the receiver to the given SQL type.  You can specify a ruby class as a type,
       # and it is handled similarly to using a database independent type in the schema methods.
       #
       #   Sequel.cast(:a, :integer) # CAST(a AS integer)
@@ -380,7 +380,7 @@ module Sequel
         SQL::Cast.new(arg, sql_type)
       end
 
-      # Cast the reciever to the given SQL type (or the database's default Integer type if none given),
+      # Cast the receiver to the given SQL type (or the database's default Integer type if none given),
       # and return the result as a +NumericExpression+, so you can use the bitwise operators
       # on the result. 
       #
@@ -390,7 +390,7 @@ module Sequel
         cast(arg, sql_type || Integer).sql_number
       end
 
-      # Cast the reciever to the given SQL type (or the database's default String type if none given),
+      # Cast the receiver to the given SQL type (or the database's default String type if none given),
       # and return the result as a +StringExpression+, so you can use +
       # directly on the result for SQL string concatenation.
       #
@@ -687,7 +687,7 @@ module Sequel
 
     # Holds methods that are used to cast objects to different SQL types.
     module CastMethods 
-      # Cast the reciever to the given SQL type.  You can specify a ruby class as a type,
+      # Cast the receiver to the given SQL type.  You can specify a ruby class as a type,
       # and it is handled similarly to using a database independent type in the schema methods.
       #
       #   Sequel.function(:func).cast(:integer) # CAST(func() AS integer)
@@ -696,7 +696,7 @@ module Sequel
         Cast.new(self, sql_type)
       end
 
-      # Cast the reciever to the given SQL type (or the database's default Integer type if none given),
+      # Cast the receiver to the given SQL type (or the database's default Integer type if none given),
       # and return the result as a +NumericExpression+, so you can use the bitwise operators
       # on the result. 
       #
@@ -706,7 +706,7 @@ module Sequel
         Cast.new(self, sql_type || Integer).sql_number
       end
 
-      # Cast the reciever to the given SQL type (or the database's default String type if none given),
+      # Cast the receiver to the given SQL type (or the database's default String type if none given),
       # and return the result as a +StringExpression+, so you can use +
       # directly on the result for SQL string concatenation.
       #
@@ -1060,123 +1060,127 @@ module Sequel
     # in a boolean value in SQL.
     class BooleanExpression < ComplexExpression
       include BooleanMethods
-      
-      # Take pairs of values (e.g. a hash or array of two element arrays)
-      # and converts it to a +BooleanExpression+.  The operator and args
-      # used depends on the case of the right (2nd) argument:
-      #
-      # 0..10 :: left >= 0 AND left <= 10
-      # [1,2] :: left IN (1,2)
-      # nil :: left IS NULL
-      # true :: left IS TRUE 
-      # false :: left IS FALSE 
-      # /as/ :: left ~ 'as'
-      # :blah :: left = blah
-      # 'blah' :: left = 'blah'
-      #
-      # If multiple arguments are given, they are joined with the op given (AND
-      # by default, OR possible).  If negate is set to true,
-      # all subexpressions are inverted before used.  Therefore, the following
-      # expressions are equivalent:
-      #
-      #   ~from_value_pairs(hash)
-      #   from_value_pairs(hash, :OR, true)
-      def self.from_value_pairs(pairs, op=:AND, negate=false)
-        pairs = pairs.map{|l,r| from_value_pair(l, r)}
-        pairs.map!{|ce| invert(ce)} if negate
-        pairs.length == 1 ? pairs[0] : new(op, *pairs)
-      end
-
-      # Return a BooleanExpression based on the right side of the pair.
-      def self.from_value_pair(l, r)
-        case r
-        when Range
-          unless r.begin.nil?
-            begin_expr = new(:>=, l, r.begin)
-          end
-          unless r.end.nil?
-            end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
-          end
-          if begin_expr
-            if end_expr
-              new(:AND, begin_expr, end_expr)
+
+      module ClassMethods
+        # Take pairs of values (e.g. a hash or array of two element arrays)
+        # and converts it to a +BooleanExpression+.  The operator and args
+        # used depends on the case of the right (2nd) argument:
+        #
+        # 0..10 :: left >= 0 AND left <= 10
+        # [1,2] :: left IN (1,2)
+        # nil :: left IS NULL
+        # true :: left IS TRUE 
+        # false :: left IS FALSE 
+        # /as/ :: left ~ 'as'
+        # :blah :: left = blah
+        # 'blah' :: left = 'blah'
+        #
+        # If multiple arguments are given, they are joined with the op given (AND
+        # by default, OR possible).  If negate is set to true,
+        # all subexpressions are inverted before used.  Therefore, the following
+        # expressions are equivalent:
+        #
+        #   ~from_value_pairs(hash)
+        #   from_value_pairs(hash, :OR, true)
+        def from_value_pairs(pairs, op=:AND, negate=false)
+          pairs = pairs.map{|l,r| from_value_pair(l, r)}
+          pairs.map!{|ce| invert(ce)} if negate
+          pairs.length == 1 ? pairs[0] : new(op, *pairs)
+        end
+
+        # Return a BooleanExpression based on the right side of the pair.
+        def from_value_pair(l, r)
+          case r
+          when Range
+            unless r.begin.nil?
+              begin_expr = new(:>=, l, r.begin)
+            end
+            unless r.end.nil?
+              end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
+            end
+            if begin_expr
+              if end_expr
+                new(:AND, begin_expr, end_expr)
+              else
+                begin_expr
+              end
+            elsif end_expr
+              end_expr
             else
-              begin_expr
+              new(:'=', 1, 1)
             end
-          elsif end_expr
-            end_expr
-          else
-            new(:'=', 1, 1)
-          end
-        when ::Array, ::Set
-          r = r.dup.freeze unless r.frozen?
-          new(:IN, l, r)
-        when ::String
-          r = r.dup.freeze unless r.frozen?
-          new(:'=', l, r)
-        when ::Sequel::Dataset
-          new(:IN, l, r)
-        when NegativeBooleanConstant
-          new(:"IS NOT", l, r.constant)
-        when BooleanConstant
-          new(:IS, l, r.constant)
-        when NilClass, TrueClass, FalseClass
-          new(:IS, l, r)
-        when Regexp
-          StringExpression.like(l, r)
-        when DelayedEvaluation
-          Sequel.delay{|ds| from_value_pair(l, r.call(ds))}
-        when Dataset::PlaceholderLiteralizer::Argument
-          prev_transform = r.instance_variable_get(:@transformer)
-          r.transform do |v|
-            if prev_transform
-              v = prev_transform.call(v)
+          when ::Array, ::Set
+            r = r.dup.freeze unless r.frozen?
+            new(:IN, l, r)
+          when ::String
+            r = r.dup.freeze unless r.frozen?
+            new(:'=', l, r)
+          when ::Sequel::Dataset
+            new(:IN, l, r)
+          when NegativeBooleanConstant
+            new(:"IS NOT", l, r.constant)
+          when BooleanConstant
+            new(:IS, l, r.constant)
+          when NilClass, TrueClass, FalseClass
+            new(:IS, l, r)
+          when Regexp
+            StringExpression.like(l, r)
+          when DelayedEvaluation
+            Sequel.delay{|ds| from_value_pair(l, r.call(ds))}
+          when Dataset::PlaceholderLiteralizer::Argument
+            prev_transform = r.instance_variable_get(:@transformer)
+            r.transform do |v|
+              if prev_transform
+                v = prev_transform.call(v)
+              end
+              from_value_pair(l, v)
             end
-            from_value_pair(l, v)
+          else
+            new(:'=', l, r)
           end
-        else
-          new(:'=', l, r)
         end
-      end
-      private_class_method :from_value_pair
-      
-      # Invert the expression, if possible.  If the expression cannot
-      # be inverted, raise an error.  An inverted expression should match everything that the
-      # uninverted expression did not match, and vice-versa, except for possible issues with
-      # SQL NULL (i.e. 1 == NULL is NULL and 1 != NULL is also NULL).
-      #
-      #   BooleanExpression.invert(:a) # NOT "a"
-      def self.invert(ce)
-        case ce
-        when BooleanExpression
-          case op = ce.op
-          when :AND, :OR
-            BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
-          when :IN, :"NOT IN"
-            BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
-          else
-            if ce.args.length == 2
-              case ce.args[1]
-              when Function, LiteralString, PlaceholderLiteralString
-                # Special behavior to not push down inversion in this case because doing so
-                # can result in incorrect behavior for ANY/SOME/ALL operators.
-                BooleanExpression.new(:NOT, ce)
+        private :from_value_pair
+        
+        # Invert the expression, if possible.  If the expression cannot
+        # be inverted, raise an error.  An inverted expression should match everything that the
+        # uninverted expression did not match, and vice-versa, except for possible issues with
+        # SQL NULL (i.e. 1 == NULL is NULL and 1 != NULL is also NULL).
+        #
+        #   BooleanExpression.invert(:a) # NOT "a"
+        def invert(ce)
+          case ce
+          when BooleanExpression
+            case op = ce.op
+            when :AND, :OR
+              BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
+            when :IN, :"NOT IN"
+              BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.dup)
+            else
+              if ce.args.length == 2
+                case ce.args[1]
+                when Function, LiteralString, PlaceholderLiteralString
+                  # Special behavior to not push down inversion in this case because doing so
+                  # can result in incorrect behavior for ANY/SOME/ALL operators.
+                  BooleanExpression.new(:NOT, ce)
+                else
+                  BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.dup)
+                end
               else
-                BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
+                BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.dup)
               end
-            else
-              BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
             end
+          when StringExpression, NumericExpression
+            raise(Sequel::Error, "cannot invert #{ce.inspect}")
+          when Constant
+            ComplexExpression::CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
+          else
+            BooleanExpression.new(:NOT, ce)
           end
-        when StringExpression, NumericExpression
-          raise(Sequel::Error, "cannot invert #{ce.inspect}")
-        when Constant
-          CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
-        else
-          BooleanExpression.new(:NOT, ce)
         end
       end
 
+      extend ClassMethods
+
       # Always use an AND operator for & on BooleanExpressions
       def &(ce)
         BooleanExpression.new(:AND, self, ce)
@@ -1620,13 +1624,13 @@ module Sequel
       # of strings, where each arg in args goes between the string elements. 
       attr_reader :str
 
-      # The arguments that will be subsituted into the placeholders.
+      # The arguments that will be substituted into the placeholders.
       # Either an array of unnamed placeholders (which will be substituted in
       # order for ? characters), or a hash of named placeholders (which will be
       # substituted for :key phrases).
       attr_reader :args
 
-      # Whether to surround the expression with parantheses
+      # Whether to surround the expression with parentheses
       attr_reader :parens
 
       # Create an object with the given string, placeholder arguments, and parens flag.
@@ -1637,7 +1641,7 @@ module Sequel
         freeze
       end
 
-      # Return a copy of the that will be surrounded by parantheses.
+      # Return a copy of the that will be surrounded by parentheses.
       def with_parens
         @parens ? self : self.class.new(@str, @args, true)
       end
@@ -1749,11 +1753,11 @@ module Sequel
       include StringConcatenationMethods
       include InequalityMethods
 
-      # Map of [regexp, case_insenstive] to +ComplexExpression+ operator symbol
+      # Map of [regexp, case_insensitive] to +ComplexExpression+ operator symbol
       LIKE_MAP = {[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE}.freeze
       LIKE_MAP.each_key(&:freeze)
       
-      # Creates a SQL pattern match exprssion. left (l) is the SQL string we
+      # Creates a SQL pattern match expression. left (l) is the SQL string we
       # are matching against, and ces are the patterns we are matching.
       # The match succeeds if any of the patterns match (SQL OR).
       #

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 107
+  MINOR = 109
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.107.0
+  version: 5.109.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -386,6 +386,7 @@ files:
 - lib/sequel/plugins/primary_key_lookup_check_values.rb
 - lib/sequel/plugins/rcte_tree.rb
 - lib/sequel/plugins/require_valid_schema.rb
+- lib/sequel/plugins/select_on_skipped_update.rb
 - lib/sequel/plugins/serialization.rb
 - lib/sequel/plugins/serialization_modification_detection.rb
 - lib/sequel/plugins/sharding.rb
@@ -416,6 +417,7 @@ files:
 - lib/sequel/plugins/update_refresh.rb
 - lib/sequel/plugins/uuid.rb
 - lib/sequel/plugins/validate_associated.rb
+- lib/sequel/plugins/validate_associated_context.rb
 - lib/sequel/plugins/validation_class_methods.rb
 - lib/sequel/plugins/validation_contexts.rb
 - lib/sequel/plugins/validation_helpers.rb
@@ -448,14 +450,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []