json_p3 0.2.1 → 0.3.1

data/lib/json_p3/parser.rb

@@ -62,7 +62,7 @@ module JSONP3
   end
 
   # A JSONPath expression parser.
-  class Parser # rubocop:disable Metrics/ClassLength
+  class Parser
     def initialize(env)
       @env = env
       @name_selector = env.class::NAME_SELECTOR
@@ -74,23 +74,23 @@ module JSONP3
     # @return [Array<Segment>]
     def parse(tokens)
       stream = Stream.new(tokens)
-      stream.expect(Token::ROOT)
+      stream.expect(:token_root)
       stream.next
       parse_query(stream)
     end
 
     protected
 
-    def parse_query(stream) # rubocop:disable Metrics/MethodLength
-      segments = []
+    def parse_query(stream)
+      segments = [] # : Array[Segment]
 
       loop do
         case stream.peek.type
-        when Token::DOUBLE_DOT
+        when :token_double_dot
           token = stream.next
           selectors = parse_selectors(stream)
           segments << RecursiveDescentSegment.new(@env, token, selectors)
-        when Token::LBRACKET, Token::NAME, Token::WILD
+        when :token_lbracket, :token_name, :token_wild
           token = stream.peek
           selectors = parse_selectors(stream)
           segments << ChildSegment.new(@env, token, selectors)
@@ -102,60 +102,60 @@ module JSONP3
       segments
     end
 
-    def parse_selectors(stream) # rubocop:disable Metrics/MethodLength
+    def parse_selectors(stream)
       case stream.peek.type
-      when Token::NAME
+      when :token_name
         token = stream.next
         [@name_selector.new(@env, token, token.value)]
-      when Token::WILD
+      when :token_wild
         [WildcardSelector.new(@env, stream.next)]
-      when Token::LBRACKET
+      when :token_lbracket
         parse_bracketed_selection(stream)
       else
         []
       end
     end
 
-    def parse_bracketed_selection(stream) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
-      stream.expect Token::LBRACKET
+    def parse_bracketed_selection(stream)
+      stream.expect(:token_lbracket)
       segment_token = stream.next
 
-      selectors = []
+      selectors = [] # : Array[Selector]
 
       loop do # rubocop:disable Metrics/BlockLength
         case stream.peek.type
-        when Token::RBRACKET
+        when :token_rbracket
           break
-        when Token::INDEX
+        when :token_index
           selectors << parse_index_or_slice(stream)
-        when Token::DOUBLE_QUOTE_STRING, Token::SINGLE_QUOTE_STRING
+        when :token_double_quote_string, :token_single_quote_string
           token = stream.next
           selectors << @name_selector.new(@env, token, decode_string_literal(token))
-        when Token::COLON
+        when :token_colon
           selectors << parse_slice_selector(stream)
-        when Token::WILD
+        when :token_wild
           selectors << WildcardSelector.new(@env, stream.next)
-        when Token::FILTER
+        when :token_filter
           selectors << parse_filter_selector(stream)
-        when Token::EOI
+        when :token_eoi
           raise JSONPathSyntaxError.new("unexpected end of query", stream.next)
         else
           raise JSONPathSyntaxError.new("unexpected token in bracketed selection", stream.next)
         end
 
         case stream.peek.type
-        when Token::EOI
+        when :token_eoi
           raise JSONPathSyntaxError.new("unexpected end of selector list", stream.next)
-        when Token::RBRACKET
+        when :token_rbracket
           break
         else
-          stream.expect Token::COMMA
+          stream.expect(:token_comma)
           stream.next
-          stream.expect_not(Token::RBRACKET, "unexpected trailing comma")
+          stream.expect_not(:token_rbracket, "unexpected trailing comma")
         end
       end
 
-      stream.expect(Token::RBRACKET)
+      stream.expect(:token_rbracket)
       stream.next
 
       raise JSONPathSyntaxError.new("empty segment", segment_token) if selectors.empty?
@@ -163,29 +163,29 @@ module JSONP3
       selectors
     end
 
-    def parse_index_or_slice(stream) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def parse_index_or_slice(stream)
       token = stream.next
       index = parse_i_json_int(token)
 
-      return @index_selector.new(@env, token, index) unless stream.peek.type == Token::COLON
+      return @index_selector.new(@env, token, index) unless stream.peek.type == :token_colon
 
       stream.next # move past colon
       stop = nil
       step = nil
 
       case stream.peek.type
-      when Token::INDEX
+      when :token_index
         stop = parse_i_json_int(stream.next)
-      when Token::COLON
+      when :token_colon
         stream.next # move past colon
       end
 
-      stream.next if stream.peek.type == Token::COLON
+      stream.next if stream.peek.type == :token_colon
 
       case stream.peek.type
-      when Token::INDEX
+      when :token_index
         step = parse_i_json_int(stream.next)
-      when Token::RBRACKET
+      when :token_rbracket
         nil
       else
         error_token = stream.next
@@ -195,8 +195,8 @@ module JSONP3
       SliceSelector.new(@env, token, index, stop, step)
     end
 
-    def parse_slice_selector(stream) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      stream.expect(Token::COLON)
+    def parse_slice_selector(stream)
+      stream.expect(:token_colon)
       token = stream.next
 
       start = nil
@@ -204,18 +204,18 @@ module JSONP3
       step = nil
 
       case stream.peek.type
-      when Token::INDEX
+      when :token_index
         stop = parse_i_json_int(stream.next)
-      when Token::COLON
+      when :token_colon
         stream.next # move past colon
       end
 
-      stream.next if stream.peek.type == Token::COLON
+      stream.next if stream.peek.type == :token_colon
 
       case stream.peek.type
-      when Token::INDEX
+      when :token_index
         step = parse_i_json_int(stream.next)
-      when Token::RBRACKET
+      when :token_rbracket
         nil
       else
         error_token = stream.next
@@ -225,14 +225,14 @@ module JSONP3
       SliceSelector.new(@env, token, start, stop, step)
     end
 
-    def parse_filter_selector(stream) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def parse_filter_selector(stream)
       token = stream.next
       expression = parse_filter_expression(stream)
 
       # Raise if expression must be compared.
       if expression.is_a? FunctionExpression
         func = @env.function_extensions[expression.name]
-        if func.class::RETURN_TYPE == ExpressionType::VALUE
+        if func.class::RETURN_TYPE == :value_expression
           raise JSONPathTypeError.new("result of #{expression.name}() must be compared", expression.token)
         end
       end
@@ -245,30 +245,30 @@ module JSONP3
       FilterSelector.new(@env, token, FilterExpression.new(token, expression))
     end
 
-    def parse_filter_expression(stream, precedence = Precedence::LOWEST) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def parse_filter_expression(stream, precedence = Precedence::LOWEST) # rubocop:disable Metrics/CyclomaticComplexity
       left = case stream.peek.type
-             when Token::DOUBLE_QUOTE_STRING, Token::SINGLE_QUOTE_STRING
+             when :token_double_quote_string, :token_single_quote_string
                token = stream.next
                StringLiteral.new(token, decode_string_literal(token))
-             when Token::FALSE
+             when :token_false
                BooleanLiteral.new(stream.next, false)
-             when Token::TRUE
+             when :token_true
                BooleanLiteral.new(stream.next, true)
-             when Token::FLOAT
+             when :token_float
                parse_float_literal(stream)
-             when Token::FUNCTION
+             when :token_function
                parse_function_expression(stream)
-             when Token::INT
+             when :token_int
                parse_integer_literal(stream)
-             when Token::LPAREN
+             when :token_lparen
                parse_grouped_expression(stream)
-             when Token::NOT
+             when :token_not
                parse_prefix_expression(stream)
-             when Token::NULL
+             when :token_null
                NullLiteral.new(stream.next, nil)
-             when Token::ROOT
+             when :token_root
                parse_root_query(stream)
-             when Token::CURRENT
+             when :token_current
                parse_relative_query(stream)
              else
                token = stream.next
@@ -277,8 +277,8 @@ module JSONP3
 
       loop do
         peeked = stream.peek
-        if peeked.type == Token::EOI ||
-           peeked.type == Token::RBRACKET ||
+        if peeked.type == :token_eoi ||
+           peeked.type == :token_rbracket ||
            PRECEDENCES.fetch(peeked.type, Precedence::LOWEST) < precedence
           break
         end
@@ -313,30 +313,30 @@ module JSONP3
       end
     end
 
-    def parse_function_expression(stream) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def parse_function_expression(stream)
       token = stream.next
-      args = []
+      args = [] # : Array[Expression]
 
-      while stream.peek.type != Token::RPAREN
+      while stream.peek.type != :token_rparen
         expr = case stream.peek.type
-               when Token::DOUBLE_QUOTE_STRING, Token::SINGLE_QUOTE_STRING
+               when :token_double_quote_string, :token_single_quote_string
                  arg_token = stream.next
                  StringLiteral.new(arg_token, decode_string_literal(arg_token))
-               when Token::FALSE
+               when :token_false
                  BooleanLiteral.new(stream.next, false)
-               when Token::TRUE
+               when :token_true
                  BooleanLiteral.new(stream.next, true)
-               when Token::FLOAT
+               when :token_float
                  parse_float_literal(stream)
-               when Token::FUNCTION
+               when :token_function
                  parse_function_expression(stream)
-               when Token::INT
+               when :token_int
                  parse_integer_literal(stream)
-               when Token::NULL
+               when :token_null
                  NullLiteral.new(stream.next, nil)
-               when Token::ROOT
+               when :token_root
                  parse_root_query(stream)
-               when Token::CURRENT
+               when :token_current
                  parse_relative_query(stream)
                else
                  arg_token = stream.next
@@ -347,13 +347,13 @@ module JSONP3
 
         args << expr
 
-        if stream.peek.type != Token::RPAREN
-          stream.expect(Token::COMMA)
+        if stream.peek.type != :token_rparen
+          stream.expect(:token_comma)
           stream.next
         end
       end
 
-      stream.expect(Token::RPAREN)
+      stream.expect(:token_rparen)
       stream.next
 
       validate_function_extension_signature(token, args)
@@ -364,13 +364,13 @@ module JSONP3
       stream.next # discard "("
       expr = parse_filter_expression(stream)
 
-      while stream.peek.type != Token::RPAREN
-        raise JSONPathSyntaxError.new("unbalanced parentheses", stream.peek) if stream.peek.type == Token::EOI
+      while stream.peek.type != :token_rparen
+        raise JSONPathSyntaxError.new("unbalanced parentheses", stream.peek) if stream.peek.type == :token_eoi
 
         expr = parse_infix_expression(stream, expr)
       end
 
-      stream.expect(Token::RPAREN)
+      stream.expect(:token_rparen)
       stream.next
       expr
     end
@@ -390,7 +390,7 @@ module JSONP3
       RelativeQueryExpression.new(token, JSONPath.new(@env, parse_query(stream)))
     end
 
-    def parse_infix_expression(stream, left) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+    def parse_infix_expression(stream, left)
       token = stream.next
       precedence = PRECEDENCES.fetch(token.type, Precedence::LOWEST)
       right = parse_filter_expression(stream, precedence)
@@ -399,28 +399,28 @@ module JSONP3
         raise_for_non_comparable_function(left)
         raise_for_non_comparable_function(right)
         case token.type
-        when Token::EQ
+        when :token_eq
           EqExpression.new(token, left, right)
-        when Token::GE
+        when :token_ge
           GeExpression.new(token, left, right)
-        when Token::GT
+        when :token_gt
           GtExpression.new(token, left, right)
-        when Token::LE
+        when :token_le
           LeExpression.new(token, left, right)
-        when Token::LT
+        when :token_lt
           LtExpression.new(token, left, right)
-        when Token::NE
+        when :token_ne
           NeExpression.new(token, left, right)
         else
           raise JSONPathSyntaxError.new("unexpected token", token)
         end
       else
-        raise_for_uncompared_literal(left)
-        raise_for_uncompared_literal(right)
+        raise_for_not_compared_literal(left)
+        raise_for_not_compared_literal(right)
         case token.type
-        when Token::AND
+        when :token_and
           LogicalAndExpression.new(token, left, right)
-        when Token::OR
+        when :token_or
           LogicalOrExpression.new(token, left, right)
         else
           raise JSONPathSyntaxError.new("unexpected token", token)
@@ -428,7 +428,7 @@ module JSONP3
       end
     end
 
-    def parse_i_json_int(token) # rubocop:disable Metrics/MethodLength
+    def parse_i_json_int(token)
       value = token.value
 
       if value.length > 1 && value.start_with?("0", "-0")
@@ -450,7 +450,7 @@ module JSONP3
     end
 
     def decode_string_literal(token)
-      if token.type == Token::SINGLE_QUOTE_STRING
+      if token.type == :token_single_quote_string
         JSONP3.unescape_string(token.value, "'", token)
       else
         JSONP3.unescape_string(token.value, '"', token)
@@ -465,19 +465,19 @@ module JSONP3
       return unless expression.is_a?(FunctionExpression)
 
       func = @env.function_extensions[expression.name]
-      return unless func.class::RETURN_TYPE != ExpressionType::VALUE
+      return unless func.class::RETURN_TYPE != :value_expression
 
       raise JSONPathTypeError.new("result of #{expression.name}() is not comparable", expression.token)
     end
 
-    def raise_for_uncompared_literal(expression)
+    def raise_for_not_compared_literal(expression)
       return unless expression.is_a? FilterExpressionLiteral
 
       raise JSONPathSyntaxError.new("expression literals must be compared",
                                     expression.token)
     end
 
-    def validate_function_extension_signature(token, args) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def validate_function_extension_signature(token, args) # rubocop:disable Metrics/CyclomaticComplexity
       func = @env.function_extensions.fetch(token.value)
       count = func.class::ARG_TYPES.length
 
@@ -491,18 +491,18 @@ module JSONP3
       func.class::ARG_TYPES.each_with_index do |t, i|
         arg = args[i]
         case t
-        when ExpressionType::VALUE
+        when :value_expression
           unless arg.is_a?(FilterExpressionLiteral) ||
                  (arg.is_a?(QueryExpression) && arg.query.singular?) ||
-                 (function_return_type(arg) == ExpressionType::VALUE)
+                 (function_return_type(arg) == :value_expression)
             raise JSONPathTypeError.new("#{token.value}() argument #{i} must be of ValueType", arg.token)
           end
-        when ExpressionType::LOGICAL
+        when :logical_expression
           unless arg.is_a?(QueryExpression) || arg.is_a?(InfixExpression)
             raise JSONPathTypeError.new("#{token.value}() argument #{i} must be of LogicalType", arg.token)
           end
-        when ExpressionType::NODES
-          unless arg.is_a?(QueryExpression) || function_return_type(arg) == ExpressionType::NODES
+        when :nodes_expression
+          unless arg.is_a?(QueryExpression) || function_return_type(arg) == :nodes_expression
             raise JSONPathTypeError.new("#{token.value}() argument #{i} must be of NodesType", arg.token)
           end
         end
@@ -518,27 +518,27 @@ module JSONP3
     end
 
     PRECEDENCES = {
-      Token::AND => Precedence::LOGICAL_AND,
-      Token::OR => Precedence::LOGICAL_OR,
-      Token::NOT => Precedence::PREFIX,
-      Token::EQ => Precedence::RELATIONAL,
-      Token::GE => Precedence::RELATIONAL,
-      Token::GT => Precedence::RELATIONAL,
-      Token::LE => Precedence::RELATIONAL,
-      Token::LT => Precedence::RELATIONAL,
-      Token::NE => Precedence::RELATIONAL,
-      Token::RPAREN => Precedence::LOWEST
+      token_and: Precedence::LOGICAL_AND,
+      token_or: Precedence::LOGICAL_OR,
+      token_not: Precedence::PREFIX,
+      token_eq: Precedence::RELATIONAL,
+      token_ge: Precedence::RELATIONAL,
+      token_gt: Precedence::RELATIONAL,
+      token_le: Precedence::RELATIONAL,
+      token_lt: Precedence::RELATIONAL,
+      token_ne: Precedence::RELATIONAL,
+      token_rparen: Precedence::LOWEST
     }.freeze
 
     BINARY_OPERATORS = {
-      Token::AND => "&&",
-      Token::OR => "||",
-      Token::EQ => "==",
-      Token::GE => ">=",
-      Token::GT => ">",
-      Token::LE => "<=",
-      Token::LT => "<",
-      Token::NE => "!="
+      token_and: "&&",
+      token_or: "||",
+      token_eq: "==",
+      token_ge: ">=",
+      token_gt: ">",
+      token_le: "<=",
+      token_lt: "<",
+      token_ne: "!="
     }.freeze
 
     COMPARISON_OPERATORS = Set[