sequel 5.108.0 → 5.110.0

data/lib/sequel/sql.rb

@@ -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)

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 = 108
+  MINOR = 110
 
   # 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.108.0
+  version: 5.110.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: []