jmespath 1.4.0 → 1.6.2

data/lib/jmespath/nodes/function.rb

@@ -1,8 +1,8 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes
     class Function < Node
-
       FUNCTIONS = {}
 
       def initialize(children, options = {})
@@ -38,26 +38,30 @@ module JMESPath
       private
 
       def maybe_raise(error_type, message)
-        unless @disable_visit_errors
-          raise error_type, message
-        end
+        raise error_type, message unless @disable_visit_errors
       end
 
-      def call(args)
+      def call(_args)
         nil
       end
     end
 
     module TypeChecker
       def get_type(value)
-        case value
-        when String then STRING_TYPE
-        when true, false then BOOLEAN_TYPE
-        when nil then NULL_TYPE
-        when Numeric then NUMBER_TYPE
-        when Hash, Struct then OBJECT_TYPE
-        when Array then ARRAY_TYPE
-        when Expression then EXPRESSION_TYPE
+        if value.respond_to?(:to_str)
+          STRING_TYPE
+        elsif value == true || value == false
+          BOOLEAN_TYPE
+        elsif value.nil?
+          NULL_TYPE
+        elsif value.is_a?(Numeric)
+          NUMBER_TYPE
+        elsif value.respond_to?(:to_hash) || value.is_a?(Struct)
+          OBJECT_TYPE
+        elsif value.respond_to?(:to_ary)
+          ARRAY_TYPE
+        elsif value.is_a?(Expression)
+          EXPRESSION_TYPE
         end
       end
 
@@ -76,7 +80,7 @@ module JMESPath
         NULL_TYPE => 'null',
         NUMBER_TYPE => 'number',
         OBJECT_TYPE => 'object',
-        STRING_TYPE => 'string',
+        STRING_TYPE => 'string'
       }.freeze
     end
 
@@ -87,12 +91,12 @@ module JMESPath
         if args.count == 1
           value = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function abs() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function abs() expects one argument'
         end
         if Numeric === value
           value.abs
         else
-          return maybe_raise Errors::InvalidTypeError, "function abs() expects a number"
+          return maybe_raise Errors::InvalidTypeError, 'function abs() expects a number'
         end
       end
     end
@@ -104,19 +108,20 @@ module JMESPath
         if args.count == 1
           values = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function avg() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function avg() expects one argument'
         end
-        if Array === values
+        if values.respond_to?(:to_ary)
+          values = values.to_ary
           return nil if values.empty?
-          values.inject(0) do |total,n|
+          values.inject(0) do |total, n|
             if Numeric === n
               total + n
             else
-              return maybe_raise Errors::InvalidTypeError, "function avg() expects numeric values"
+              return maybe_raise Errors::InvalidTypeError, 'function avg() expects numeric values'
             end
           end / values.size.to_f
         else
-          return maybe_raise Errors::InvalidTypeError, "function avg() expects a number"
+          return maybe_raise Errors::InvalidTypeError, 'function avg() expects a number'
         end
       end
     end
@@ -128,12 +133,12 @@ module JMESPath
         if args.count == 1
           value = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function ceil() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function ceil() expects one argument'
         end
         if Numeric === value
           value.ceil
         else
-          return maybe_raise Errors::InvalidTypeError, "function ceil() expects a numeric value"
+          return maybe_raise Errors::InvalidTypeError, 'function ceil() expects a numeric value'
         end
       end
     end
@@ -144,14 +149,16 @@ module JMESPath
       def call(args)
         if args.count == 2
           haystack = args[0]
-          needle = args[1]
-          if String === haystack || Array === haystack
-            haystack.include?(needle)
+          needle = Util.as_json(args[1])
+          if haystack.respond_to?(:to_str)
+            haystack.to_str.include?(needle)
+          elsif haystack.respond_to?(:to_ary)
+            haystack.to_ary.any? { |e| Util.as_json(e) == needle }
           else
-            return maybe_raise Errors::InvalidTypeError, "contains expects 2nd arg to be a list"
+            return maybe_raise Errors::InvalidTypeError, 'contains expects 2nd arg to be a list'
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function contains() expects 2 arguments"
+          return maybe_raise Errors::InvalidArityError, 'function contains() expects 2 arguments'
         end
       end
     end
@@ -163,12 +170,12 @@ module JMESPath
         if args.count == 1
           value = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function floor() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function floor() expects one argument'
         end
         if Numeric === value
           value.floor
         else
-          return maybe_raise Errors::InvalidTypeError, "function floor() expects a numeric value"
+          return maybe_raise Errors::InvalidTypeError, 'function floor() expects a numeric value'
         end
       end
     end
@@ -180,36 +187,39 @@ module JMESPath
         if args.count == 1
           value = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function length() expects one argument"
-        end
-        case value
-        when Hash, Array, String then value.size
-        else return maybe_raise Errors::InvalidTypeError, "function length() expects string, array or object"
+          return maybe_raise Errors::InvalidArityError, 'function length() expects one argument'
+        end
+        if value.respond_to?(:to_hash)
+          value.to_hash.size
+        elsif value.respond_to?(:to_ary)
+          value.to_ary.size
+        elsif value.respond_to?(:to_str)
+          value.to_str.size
+        else
+          return maybe_raise Errors::InvalidTypeError, 'function length() expects string, array or object'
         end
       end
     end
 
     class Map < Function
-
       FUNCTIONS['map'] = self
 
       def call(args)
         if args.count != 2
-          return maybe_raise Errors::InvalidArityError, "function map() expects two arguments"
+          return maybe_raise Errors::InvalidArityError, 'function map() expects two arguments'
         end
         if Nodes::Expression === args[0]
           expr = args[0]
         else
-          return maybe_raise Errors::InvalidTypeError, "function map() expects the first argument to be an expression"
+          return maybe_raise Errors::InvalidTypeError, 'function map() expects the first argument to be an expression'
         end
-        if Array === args[1]
-          list = args[1]
+        if args[1].respond_to?(:to_ary)
+          list = args[1].to_ary
         else
-          return maybe_raise Errors::InvalidTypeError, "function map() expects the second argument to be an list"
+          return maybe_raise Errors::InvalidTypeError, 'function map() expects the second argument to be an list'
         end
         list.map { |value| expr.eval(value) }
       end
-
     end
 
     class MaxFunction < Function
@@ -221,14 +231,15 @@ module JMESPath
         if args.count == 1
           values = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function max() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function max() expects one argument'
         end
-        if Array === values
+        if values.respond_to?(:to_ary)
+          values = values.to_ary
           return nil if values.empty?
           first = values.first
           first_type = get_type(first)
           unless first_type == NUMBER_TYPE || first_type == STRING_TYPE
-            msg = "function max() expects numeric or string values"
+            msg = String.new('function max() expects numeric or string values')
             return maybe_raise Errors::InvalidTypeError, msg
           end
           values.inject([first, first_type]) do |(max, max_type), v|
@@ -236,13 +247,13 @@ module JMESPath
             if max_type == v_type
               v > max ? [v, v_type] : [max, max_type]
             else
-              msg = "function max() encountered a type mismatch in sequence: "
+              msg = String.new('function max() encountered a type mismatch in sequence: ')
               msg << "#{max_type}, #{v_type}"
               return maybe_raise Errors::InvalidTypeError, msg
             end
           end.first
         else
-          return maybe_raise Errors::InvalidTypeError, "function max() expects an array"
+          return maybe_raise Errors::InvalidTypeError, 'function max() expects an array'
         end
       end
     end
@@ -256,14 +267,15 @@ module JMESPath
         if args.count == 1
           values = args.first
         else
-          return maybe_raise Errors::InvalidArityError, "function min() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function min() expects one argument'
         end
-        if Array === values
+        if values.respond_to?(:to_ary)
+          values = values.to_ary
           return nil if values.empty?
           first = values.first
           first_type = get_type(first)
           unless first_type == NUMBER_TYPE || first_type == STRING_TYPE
-            msg = "function min() expects numeric or string values"
+            msg = String.new('function min() expects numeric or string values')
             return maybe_raise Errors::InvalidTypeError, msg
           end
           values.inject([first, first_type]) do |(min, min_type), v|
@@ -271,13 +283,13 @@ module JMESPath
             if min_type == v_type
               v < min ? [v, v_type] : [min, min_type]
             else
-              msg = "function min() encountered a type mismatch in sequence: "
+              msg = String.new('function min() encountered a type mismatch in sequence: ')
               msg << "#{min_type}, #{v_type}"
               return maybe_raise Errors::InvalidTypeError, msg
             end
           end.first
         else
-          return maybe_raise Errors::InvalidTypeError, "function min() expects an array"
+          return maybe_raise Errors::InvalidTypeError, 'function min() expects an array'
         end
       end
     end
@@ -291,7 +303,7 @@ module JMESPath
         if args.count == 1
           TYPE_NAMES[get_type(args.first)]
         else
-          return maybe_raise Errors::InvalidArityError, "function type() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function type() expects one argument'
         end
       end
     end
@@ -302,17 +314,15 @@ module JMESPath
       def call(args)
         if args.count == 1
           value = args.first
-          if hash_like?(value)
-            case value
-            when Hash then value.keys.map(&:to_s)
-            when Struct then value.members.map(&:to_s)
-            else raise NotImplementedError
-            end
+          if value.respond_to?(:to_hash)
+            value.to_hash.keys.map(&:to_s)
+          elsif value.is_a?(Struct)
+            value.members.map(&:to_s)
           else
-            return maybe_raise Errors::InvalidTypeError, "function keys() expects a hash"
+            return maybe_raise Errors::InvalidTypeError, 'function keys() expects a hash'
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function keys() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function keys() expects one argument'
         end
       end
     end
@@ -323,15 +333,17 @@ module JMESPath
       def call(args)
         if args.count == 1
           value = args.first
-          if hash_like?(value)
+          if value.respond_to?(:to_hash)
+            value.to_hash.values
+          elsif value.is_a?(Struct)
             value.values
-          elsif Array === value
-            value
+          elsif value.respond_to?(:to_ary)
+            value.to_ary
           else
-            return maybe_raise Errors::InvalidTypeError, "function values() expects an array or a hash"
+            return maybe_raise Errors::InvalidTypeError, 'function values() expects an array or a hash'
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function values() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function values() expects one argument'
         end
       end
     end
@@ -343,15 +355,15 @@ module JMESPath
         if args.count == 2
           glue = args[0]
           values = args[1]
-          if !(String === glue)
-            return maybe_raise Errors::InvalidTypeError, "function join() expects the first argument to be a string"
-          elsif Array === values && values.all? { |v| String === v }
-            values.join(glue)
+          if !glue.respond_to?(:to_str)
+            return maybe_raise Errors::InvalidTypeError, 'function join() expects the first argument to be a string'
+          elsif values.respond_to?(:to_ary) && values.to_ary.all? { |v| v.respond_to?(:to_str) }
+            values.to_ary.join(glue)
           else
-            return maybe_raise Errors::InvalidTypeError, "function join() expects values to be an array of strings"
+            return maybe_raise Errors::InvalidTypeError, 'function join() expects values to be an array of strings'
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function join() expects an array of strings"
+          return maybe_raise Errors::InvalidArityError, 'function join() expects an array of strings'
         end
       end
     end
@@ -362,9 +374,9 @@ module JMESPath
       def call(args)
         if args.count == 1
           value = args.first
-          String === value ? value : value.to_json
+          value.respond_to?(:to_str) ? value.to_str : value.to_json
         else
-          return maybe_raise Errors::InvalidArityError, "function to_string() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function to_string() expects one argument'
         end
       end
     end
@@ -381,7 +393,7 @@ module JMESPath
             nil
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function to_number() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function to_number() expects one argument'
         end
       end
     end
@@ -390,16 +402,16 @@ module JMESPath
       FUNCTIONS['sum'] = self
 
       def call(args)
-        if args.count == 1 && Array === args.first
-          args.first.inject(0) do |sum,n|
+        if args.count == 1 && args.first.respond_to?(:to_ary)
+          args.first.to_ary.inject(0) do |sum, n|
             if Numeric === n
               sum + n
             else
-              return maybe_raise Errors::InvalidTypeError, "function sum() expects values to be numeric"
+              return maybe_raise Errors::InvalidTypeError, 'function sum() expects values to be numeric'
             end
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function sum() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function sum() expects one argument'
         end
       end
     end
@@ -411,7 +423,7 @@ module JMESPath
         if args.count > 0
           args.find { |value| !value.nil? }
         else
-          return maybe_raise Errors::InvalidArityError, "function not_null() expects one or more arguments"
+          return maybe_raise Errors::InvalidArityError, 'function not_null() expects one or more arguments'
         end
       end
     end
@@ -424,29 +436,30 @@ module JMESPath
       def call(args)
         if args.count == 1
           value = args.first
-          if Array === value
+          if value.respond_to?(:to_ary)
+            value = value.to_ary
             # every element in the list must be of the same type
             array_type = get_type(value[0])
-            if array_type == STRING_TYPE || array_type == NUMBER_TYPE || value.size == 0
+            if array_type == STRING_TYPE || array_type == NUMBER_TYPE || value.empty?
               # stable sort
               n = 0
               value.sort_by do |v|
                 value_type = get_type(v)
                 if value_type != array_type
-                  msg = "function sort() expects values to be an array of only numbers, or only integers"
+                  msg = 'function sort() expects values to be an array of only numbers, or only integers'
                   return maybe_raise Errors::InvalidTypeError, msg
                 end
                 n += 1
                 [v, n]
               end
             else
-              return maybe_raise Errors::InvalidTypeError, "function sort() expects values to be an array of numbers or integers"
+              return maybe_raise Errors::InvalidTypeError, 'function sort() expects values to be an array of numbers or integers'
             end
           else
-            return maybe_raise Errors::InvalidTypeError, "function sort() expects values to be an array of numbers or integers"
+            return maybe_raise Errors::InvalidTypeError, 'function sort() expects values to be an array of numbers or integers'
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function sort() expects one argument"
+          return maybe_raise Errors::InvalidArityError, 'function sort() expects one argument'
         end
       end
     end
@@ -459,30 +472,30 @@ module JMESPath
       def call(args)
         if args.count == 2
           if get_type(args[0]) == ARRAY_TYPE && get_type(args[1]) == EXPRESSION_TYPE
-            values = args[0]
+            values = args[0].to_ary
             expression = args[1]
             array_type = get_type(expression.eval(values[0]))
-            if array_type == STRING_TYPE || array_type == NUMBER_TYPE || values.size == 0
+            if array_type == STRING_TYPE || array_type == NUMBER_TYPE || values.empty?
               # stable sort the list
               n = 0
               values.sort_by do |value|
                 value = expression.eval(value)
                 value_type = get_type(value)
                 if value_type != array_type
-                  msg = "function sort() expects values to be an array of only numbers, or only integers"
+                  msg = 'function sort() expects values to be an array of only numbers, or only integers'
                   return maybe_raise Errors::InvalidTypeError, msg
                 end
                 n += 1
                 [value, n]
               end
             else
-              return maybe_raise Errors::InvalidTypeError, "function sort() expects values to be an array of numbers or integers"
+              return maybe_raise Errors::InvalidTypeError, 'function sort() expects values to be an array of numbers or integers'
             end
           else
-            return maybe_raise Errors::InvalidTypeError, "function sort_by() expects an array and an expression"
+            return maybe_raise Errors::InvalidTypeError, 'function sort_by() expects an array and an expression'
           end
         else
-          return maybe_raise Errors::InvalidArityError, "function sort_by() expects two arguments"
+          return maybe_raise Errors::InvalidArityError, 'function sort_by() expects two arguments'
         end
       end
     end
@@ -495,6 +508,7 @@ module JMESPath
           values = args[0]
           expression = args[1]
           if get_type(values) == ARRAY_TYPE && get_type(expression) == EXPRESSION_TYPE
+            values = values.to_ary
             type = get_type(expression.eval(values.first))
             if type != NUMBER_TYPE && type != STRING_TYPE
               msg = "function #{mode}() expects values to be strings or numbers"
@@ -504,7 +518,7 @@ module JMESPath
               value = expression.eval(entry)
               value_type = get_type(value)
               if value_type != type
-                msg = "function #{mode}() encountered a type mismatch in "
+                msg = String.new("function #{mode}() encountered a type mismatch in ")
                 msg << "sequence: #{type}, #{value_type}"
                 return maybe_raise Errors::InvalidTypeError, msg
               end
@@ -552,16 +566,16 @@ module JMESPath
           search_type = get_type(search)
           suffix_type = get_type(suffix)
           if search_type != STRING_TYPE
-            msg = "function ends_with() expects first argument to be a string"
+            msg = 'function ends_with() expects first argument to be a string'
             return maybe_raise Errors::InvalidTypeError, msg
           end
           if suffix_type != STRING_TYPE
-            msg = "function ends_with() expects second argument to be a string"
+            msg = 'function ends_with() expects second argument to be a string'
             return maybe_raise Errors::InvalidTypeError, msg
           end
           search.end_with?(suffix)
         else
-          msg = "function ends_with() expects two arguments"
+          msg = 'function ends_with() expects two arguments'
           return maybe_raise Errors::InvalidArityError, msg
         end
       end
@@ -578,16 +592,16 @@ module JMESPath
           search_type = get_type(search)
           prefix_type = get_type(prefix)
           if search_type != STRING_TYPE
-            msg = "function starts_with() expects first argument to be a string"
+            msg = 'function starts_with() expects first argument to be a string'
             return maybe_raise Errors::InvalidTypeError, msg
           end
           if prefix_type != STRING_TYPE
-            msg = "function starts_with() expects second argument to be a string"
+            msg = 'function starts_with() expects second argument to be a string'
             return maybe_raise Errors::InvalidTypeError, msg
           end
           search.start_with?(prefix)
         else
-          msg = "function starts_with() expects two arguments"
+          msg = 'function starts_with() expects two arguments'
           return maybe_raise Errors::InvalidArityError, msg
         end
       end
@@ -598,7 +612,7 @@ module JMESPath
 
       def call(args)
         if args.count == 0
-          msg = "function merge() expects 1 or more arguments"
+          msg = 'function merge() expects 1 or more arguments'
           return maybe_raise Errors::InvalidArityError, msg
         end
         args.inject({}) do |h, v|
@@ -612,14 +626,16 @@ module JMESPath
 
       def call(args)
         if args.count == 0
-          msg = "function reverse() expects 1 or more arguments"
+          msg = 'function reverse() expects 1 or more arguments'
           return maybe_raise Errors::InvalidArityError, msg
         end
         value = args.first
-        if Array === value || String === value
-          value.reverse
+        if value.respond_to?(:to_ary)
+          value.to_ary.reverse
+        elsif value.respond_to?(:to_str)
+          value.to_str.reverse
         else
-          msg = "function reverse() expects an array or string"
+          msg = 'function reverse() expects an array or string'
           return maybe_raise Errors::InvalidTypeError, msg
         end
       end
@@ -630,7 +646,7 @@ module JMESPath
 
       def call(args)
         value = args.first
-        Array === value ? value : [value]
+        value.respond_to?(:to_ary) ? value.to_ary : [value]
       end
     end
   end

data/lib/jmespath/nodes/index.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes

data/lib/jmespath/nodes/literal.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes
@@ -8,7 +9,7 @@ module JMESPath
         @value = value
       end
 
-      def visit(value)
+      def visit(_value)
         @value
       end
     end

data/lib/jmespath/nodes/multi_select_hash.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes

data/lib/jmespath/nodes/multi_select_list.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes

data/lib/jmespath/nodes/not.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module JMESPath
   module Nodes
     class Not < Node
-
       def initialize(expression)
         @expression = expression
       end
@@ -13,7 +13,6 @@ module JMESPath
       def optimize
         self.class.new(@expression.optimize)
       end
-
     end
   end
 end

data/lib/jmespath/nodes/or.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes

data/lib/jmespath/nodes/pipe.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Nodes