jmespath 1.5.0 → 1.6.2

data/lib/jmespath/parser.rb

@@ -1,28 +1,28 @@
+# frozen_string_literal: true
 require 'set'
 
 module JMESPath
   # @api private
   class Parser
-
     AFTER_DOT = Set.new([
-      Lexer::T_IDENTIFIER,        # foo.bar
-      Lexer::T_QUOTED_IDENTIFIER, # foo."bar"
-      Lexer::T_STAR,              # foo.*
-      Lexer::T_LBRACE,            # foo{a: 0}
-      Lexer::T_LBRACKET,          # foo[1]
-      Lexer::T_FILTER,            # foo.[?bar==10]
-    ])
+                          Lexer::T_IDENTIFIER, # foo.bar
+                          Lexer::T_QUOTED_IDENTIFIER, # foo."bar"
+                          Lexer::T_STAR,              # foo.*
+                          Lexer::T_LBRACE,            # foo{a: 0}
+                          Lexer::T_LBRACKET,          # foo[1]
+                          Lexer::T_FILTER,            # foo.[?bar==10]
+                        ])
 
     NUM_COLON_RBRACKET = Set.new([
-      Lexer::T_NUMBER,
-      Lexer::T_COLON,
-      Lexer::T_RBRACKET,
-    ])
+                                   Lexer::T_NUMBER,
+                                   Lexer::T_COLON,
+                                   Lexer::T_RBRACKET
+                                 ])
 
     COLON_RBRACKET = Set.new([
-      Lexer::T_COLON,
-      Lexer::T_RBRACKET,
-    ])
+                               Lexer::T_COLON,
+                               Lexer::T_RBRACKET
+                             ])
 
     CURRENT_NODE = Nodes::Current.new
 
@@ -34,7 +34,7 @@ module JMESPath
 
     # @param [String<JMESPath>] expression
     def parse(expression)
-      tokens =  @lexer.tokenize(expression)
+      tokens = @lexer.tokenize(expression)
       stream = TokenStream.new(expression, tokens)
       result = expr(stream)
       if stream.token.type != Lexer::T_EOF
@@ -110,13 +110,11 @@ module JMESPath
 
     def nud_lbrace(stream)
       valid_keys = Set.new([:quoted_identifier, :identifier])
-      stream.next(match:valid_keys)
+      stream.next(match: valid_keys)
       pairs = []
       begin
         pairs << parse_key_value_pair(stream)
-        if stream.token.type == :comma
-          stream.next(match:valid_keys)
-        end
+        stream.next(match: valid_keys) if stream.token.type == :comma
       end while stream.token.type != :rbrace
       stream.next
       Nodes::MultiSelectHash.new(pairs)
@@ -167,7 +165,7 @@ module JMESPath
     end
 
     def led_dot(stream, left)
-      stream.next(match:AFTER_DOT)
+      stream.next(match: AFTER_DOT)
       if stream.token.type == :star
         parse_wildcard_object(stream, left)
       else
@@ -217,12 +215,10 @@ module JMESPath
       stream.next
       while stream.token.type != :rparen
         args << expr(stream, 0)
-        if stream.token.type == :comma
-          stream.next
-        end
+        stream.next if stream.token.type == :comma
       end
       stream.next
-      Nodes::Function.create(name, args, :disable_visit_errors => @disable_visit_errors)
+      Nodes::Function.create(name, args, disable_visit_errors: @disable_visit_errors)
     end
 
     def led_or(stream, left)
@@ -286,7 +282,7 @@ module JMESPath
 
     def parse_key_value_pair(stream)
       key = stream.token.value
-      stream.next(match:Set.new([:colon]))
+      stream.next(match: Set.new([:colon]))
       stream.next
       Nodes::MultiSelectHash::KeyValuePair.new(key, expr(stream))
     end
@@ -311,7 +307,7 @@ module JMESPath
       if stream.token.binding_power < 10
         CURRENT_NODE
       elsif type == :dot
-        stream.next(match:AFTER_DOT)
+        stream.next(match: AFTER_DOT)
         parse_dot(stream, binding_power)
       elsif type == :lbracket || type == :filter
         expr(stream, binding_power)
@@ -321,7 +317,7 @@ module JMESPath
     end
 
     def parse_wildcard_array(stream, left = nil)
-      stream.next(match:Set.new([:rbracket]))
+      stream.next(match: Set.new([:rbracket]))
       stream.next
       left ||= CURRENT_NODE
       right = parse_projection(stream, Token::BINDING_POWER[:star])
@@ -334,6 +330,5 @@ module JMESPath
       right = parse_projection(stream, Token::BINDING_POWER[:star])
       Nodes::ObjectProjection.new(left, right)
     end
-
   end
 end

data/lib/jmespath/runtime.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   class Runtime
-
     # @api private
     DEFAULT_PARSER = CachingParser
 
@@ -66,6 +66,5 @@ module JMESPath
         DEFAULT_PARSER.new(options)
       end
     end
-
   end
 end

data/lib/jmespath/token.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   class Token < Struct.new(:type, :value, :position, :binding_power)
-
     NULL_TOKEN = Token.new(:eof, '', nil)
 
     BINDING_POWER = {
@@ -28,8 +28,8 @@ module JMESPath
       Lexer::T_NOT               => 45,
       Lexer::T_LBRACE            => 50,
       Lexer::T_LBRACKET          => 55,
-      Lexer::T_LPAREN            => 60,
-    }
+      Lexer::T_LPAREN            => 60
+    }.freeze
 
     # @param [Symbol] type
     # @param [Mixed] value
@@ -37,6 +37,5 @@ module JMESPath
     def initialize(type, value, position)
       super(type, value, position, BINDING_POWER[type])
     end
-
   end
 end

data/lib/jmespath/token_stream.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   class TokenStream
-
     # @param [String<JMESPath>] expression
     # @param [Array<Token>] tokens
     def initialize(expression, tokens)
@@ -35,8 +35,8 @@ module JMESPath
     def inspect
       str = []
       @tokens.each do |token|
-        str << "%3d  %-15s %s" %
-         [token.position, token.type, token.value.inspect]
+        str << '%3d  %-15s %s' %
+               [token.position, token.type, token.value.inspect]
       end
       str.join("\n")
     end
@@ -50,11 +50,10 @@ module JMESPath
 
     def validate_match(token, match)
       if match && !match.include?(token.type)
-        raise Errors::SyntaxError, "type missmatch"
+        raise Errors::SyntaxError, 'type missmatch'
       else
         token
       end
     end
-
   end
 end

data/lib/jmespath/util.rb

@@ -1,18 +1,18 @@
+# frozen_string_literal: true
 module JMESPath
   # @api private
   module Util
     class << self
-
       # Determines if a value is false as defined by JMESPath:
       #
       #   https://github.com/jmespath/jmespath.site/blob/master/docs/proposals/improved-filters.rst#and-expressions-1
       #
       def falsey?(value)
         !value ||
-        (value.respond_to?(:to_ary) && value.to_ary.empty?) ||
-        (value.respond_to?(:to_hash) && value.to_hash.empty?) ||
-        (value.respond_to?(:to_str) && value.to_str.empty?) ||
-        (value.respond_to?(:entries) && !value.entries.any?)
+          (value.respond_to?(:to_ary) && value.to_ary.empty?) ||
+          (value.respond_to?(:to_hash) && value.to_hash.empty?) ||
+          (value.respond_to?(:to_str) && value.to_str.empty?) ||
+          (value.respond_to?(:entries) && !value.entries.any?)
         # final case necessary to support Enumerable and Struct
       end
 

data/lib/jmespath/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JMESPath
   VERSION = File.read(File.expand_path('../../../VERSION', __FILE__)).strip
 end

data/lib/jmespath.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
 require 'json'
 require 'stringio'
 require 'pathname'
 
 module JMESPath
-
   require 'jmespath/caching_parser'
   require 'jmespath/errors'
   require 'jmespath/lexer'
@@ -16,7 +16,6 @@ module JMESPath
   require 'jmespath/version'
 
   class << self
-
     # @param [String] expression A valid
     #   [JMESPath](https://github.com/boto/jmespath) expression.
     # @param [Hash] data
@@ -24,18 +23,17 @@ module JMESPath
     #   expression does not resolve inside `data`.
     def search(expression, data, runtime_options = {})
       data = case data
-        when Hash, Struct then data # check for most common case first
-        when Pathname then load_json(data)
-        when IO, StringIO then JSON.load(data.read)
-        else data
+             when Hash, Struct then data # check for most common case first
+             when Pathname then load_json(data)
+             when IO, StringIO then JSON.parse(data.read)
+             else data
         end
       Runtime.new(runtime_options).search(expression, data)
     end
 
     # @api private
     def load_json(path)
-      JSON.load(File.open(path, 'r', encoding: 'UTF-8') { |f| f.read })
+      JSON.parse(File.open(path, 'r', encoding: 'UTF-8', &:read))
     end
-
   end
 end

metadata

@@ -1,23 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: jmespath
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.2
 platform: ruby
 authors:
 - Trevor Rowe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-10 00:00:00.000000000 Z
+date: 2022-11-25 00:00:00.000000000 Z
 dependencies: []
 description: Implements JMESPath for Ruby
 email: trevorrowe@gmail.com
-executables: []
+executables:
+- jmespath.rb
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
 - VERSION
+- bin/jmespath.rb
 - lib/jmespath.rb
 - lib/jmespath/caching_parser.rb
 - lib/jmespath/errors.rb
@@ -66,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.7
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: JMESPath - Ruby Edition