hecks 3.4.2 → 3.6.0

data/lib/hecks/bluebook/expression/evaluator/scanning.rb

@@ -0,0 +1,122 @@
+require_relative "../resolver"
+
+module Hecks
+  module Bluebook
+    module Expression
+      module Evaluator
+        # Finds the split points of a predicate's text: outermost parens, `||`/`&&`, comparison
+        # operators and the `.include?(...)` call, skipping anything inside quotes or brackets.
+        module Scanning
+          module_function
+
+          # Quote characters a predicate may open a string literal with.
+          QUOTES = ['"', "'"].freeze
+
+          # How each bracket moves the nesting depth. `{`/`}` and `[`/`]` count like parens: an
+          # operator inside a block predicate (`.all? { |s| s.length > 0 }`) or an array literal
+          # (`[0, 0 + 0]`) must not read as a split point for the enclosing expression.
+          BRACKETS = { "(" => 1, "{" => 1, "[" => 1, ")" => -1, "}" => -1, "]" => -1 }.freeze
+
+          # Tracks quote and bracket nesting while a predicate is read left to right.
+          class Position
+            def initialize
+              @depth = 0
+              @quote = nil
+            end
+
+            # Consumes the next character.
+            #
+            # @param char [String] the character at the current position
+            # @return [Boolean] whether `char` sits at the top level, outside quotes and brackets
+            def top_level?(char)
+              if @quote
+                @quote = nil if char == @quote
+              elsif QUOTES.include?(char)
+                @quote = char
+              elsif BRACKETS.key?(char)
+                @depth += BRACKETS.fetch(char)
+              else
+                return @depth.zero?
+              end
+              false
+            end
+          end
+
+          # Splits `expr` at its outermost `.include?(...)` call, if any.
+          # `rindex` would find an innermost call inside the needle, so try each occurrence left to
+          # right and keep the first whose matching paren reaches the last character.
+          def match_include(expr)
+            start = 0
+            marker = ".include?("
+            while (index = expr.index(marker, start))
+              close = Resolver.matching_paren(expr, index + marker.length)
+              return [expr[0...index], expr[(index + marker.length)...close]] if close == expr.length - 1
+
+              start = index + 1
+            end
+            nil
+          end
+
+          # Strips redundant outer parens, recursively.
+          def strip_parens(expr)
+            return expr unless wrapped_in_parens?(expr)
+
+            strip_parens(expr[1..-2].strip)
+          end
+
+          # Whether one pair of parens spans the whole of `expr`.
+          def wrapped_in_parens?(expr)
+            return false unless expr.start_with?("(") && expr.end_with?(")")
+
+            depth = 0
+            closes_early = expr.each_char.with_index.any? do |char, index|
+              depth += BRACKETS.fetch(char, 0) if ["(", ")"].include?(char)
+              depth.zero? && index < expr.length - 1
+            end
+            !closes_early
+          end
+
+          # Splits `expr` at its first top-level `operator`.
+          def split_top_level(expr, operator)
+            index = top_level_index(expr, operator)
+            return nil unless index
+
+            [expr[0...index].strip, expr[(index + operator.length)..].strip]
+          end
+
+          # Splits `expr` at its first top-level `operator` that is not part of a longer one
+          # (`==` inside `===`, `<` in `<=`).
+          def split_comparison(expr, operator)
+            index = top_level_index(expr, operator) { |at| !part_of_longer?(expr, at, operator) }
+            return nil unless index
+
+            [expr[0...index].strip, expr[(index + operator.length)..].strip]
+          end
+
+          # Whether the `operator` at `index` is part of a longer operator's spelling.
+          def part_of_longer?(expr, index, operator)
+            after  = expr[index + operator.length]
+            before = index.positive? ? expr[index - 1] : nil
+
+            return true if after == "=" && !operator.end_with?("=")
+            return true if ["<", ">", "!", "="].include?(before) && operator.start_with?("=")
+
+            false
+          end
+
+          # Finds the first top-level occurrence of `operator`, tracking quotes and all bracket
+          # kinds so an operator inside a call, block predicate or array literal is skipped.
+          def top_level_index(expr, operator)
+            position = Position.new
+            expr.each_char.with_index do |char, index|
+              next unless position.top_level?(char) && expr[index, operator.length] == operator
+
+              return index if !block_given? || yield(index)
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/expression/evaluator.rb

@@ -1,5 +1,6 @@
 require "json"
 require_relative "../../vocabulary"
+require_relative "evaluator/parser"
 
 module Hecks
   module Bluebook
@@ -93,36 +94,21 @@ module Hecks
         end
 
         # Parses `expr`'s boolean/comparison grammar into an AST; leaves go to `Resolver.parse`.
-        def parse(expr)
-          expr = strip_parens(expr.to_s.strip)
+        def parse(expr) = Parser.parse(expr)
 
-          left, right = split_top_level(expr, "||")
-          return Or.new(left: parse(left), right: parse(right)) if left
-
-          left, right = split_top_level(expr, "&&")
-          return And.new(left: parse(left), right: parse(right)) if left
-
-          # `!` binds the whole remainder, so strip it before `match_include` runs;
-          # otherwise `!names.include?(x)` would swallow the `!` into the haystack text.
-          return Not.new(node: parse(Regexp.last_match(1))) if expr =~ /\A!(.+)\z/
-
-          membership = match_include(expr)
-          return Include.new(haystack: Resolver.parse(membership[0]), needle: Resolver.parse(membership[1])) if membership
-
-          OPERATORS.each do |op|
-            left, right = split_comparison(expr, op.symbol)
-            return Compare.new(operator: op, left: Resolver.parse(left), right: Resolver.parse(right)) if left
+        # Interprets a parsed boolean/comparison node against `state`/`attrs`.
+        def interpret(node, state, attrs)
+          case node
+          when Or  then interpret(node.left, state, attrs) || interpret(node.right, state, attrs)
+          when And then interpret(node.left, state, attrs) && interpret(node.right, state, attrs)
+          when Not then !interpret(node.node, state, attrs)
+          else interpret_test(node, state, attrs)
           end
-
-          Resolve.new(expr: Resolver.parse(expr))
         end
 
-        # Interprets a parsed boolean/comparison node against `state`/`attrs`.
-        def interpret(node, state, attrs)
+        # Interprets a comparison, membership or bare-resolver node.
+        def interpret_test(node, state, attrs)
           case node
-          when Or      then interpret(node.left, state, attrs) || interpret(node.right, state, attrs)
-          when And     then interpret(node.left, state, attrs) && interpret(node.right, state, attrs)
-          when Not     then !interpret(node.node, state, attrs)
           when Compare then compare(node.operator, node.left, node.right, state, attrs)
           when Include then includes?([node.haystack, node.needle], state, attrs)
           when Resolve then truthy?(Resolver.interpret(node.expr, state, attrs))
@@ -178,21 +164,6 @@ module Hecks
           value.nil? ? "nil" : value.class.name
         end
 
-        # Splits `expr` at its outermost `.include?(...)` call, if any.
-        # `rindex` would find an innermost call inside the needle, so try each occurrence left to
-        # right and keep the first whose matching paren reaches the last character.
-        def match_include(expr)
-          start = 0
-          marker = ".include?("
-          while (index = expr.index(marker, start))
-            close = Resolver.matching_paren(expr, index + marker.length)
-            return [expr[0...index], expr[(index + marker.length)...close]] if close == expr.length - 1
-
-            start = index + 1
-          end
-          nil
-        end
-
         # Held equal to Vocabulary::IncludeHaystack by spec/vocabulary_conformance_spec.
         INCLUDE_HAYSTACKS = Hecks::Vocabulary.fetch("IncludeHaystack")
 
@@ -210,77 +181,6 @@ module Hecks
           else false
           end
         end
-
-        # Strips redundant outer parens, recursively.
-        def strip_parens(expr)
-          return expr unless expr.start_with?("(") && expr.end_with?(")")
-
-          depth = 0
-          expr.each_char.with_index do |char, index|
-            depth += 1 if char == "("
-            depth -= 1 if char == ")"
-            return expr if depth.zero? && index < expr.length - 1
-          end
-          strip_parens(expr[1..-2].strip)
-        end
-
-        # Splits `expr` at its first top-level `operator`.
-        def split_top_level(expr, operator)
-          index = top_level_index(expr, operator)
-          return nil unless index
-
-          [expr[0...index].strip, expr[(index + operator.length)..].strip]
-        end
-
-        # Splits `expr` at its first top-level `operator` that is not part of a longer one
-        # (`==` inside `===`, `<` in `<=`).
-        def split_comparison(expr, operator)
-          index = top_level_index(expr, operator) { |at| !part_of_longer?(expr, at, operator) }
-          return nil unless index
-
-          [expr[0...index].strip, expr[(index + operator.length)..].strip]
-        end
-
-        # Whether the `operator` at `index` is part of a longer operator's spelling.
-        def part_of_longer?(expr, index, operator)
-          after  = expr[index + operator.length]
-          before = index.positive? ? expr[index - 1] : nil
-
-          return true if after == "=" && !operator.end_with?("=")
-          return true if ["<", ">", "!", "="].include?(before) && operator.start_with?("=")
-
-          false
-        end
-
-        # Finds the first top-level occurrence of `operator`, tracking quotes and all bracket
-        # kinds so an operator inside a call, block predicate or array literal is skipped.
-        def top_level_index(expr, operator)
-          depth = 0
-          quote = nil
-          index = 0
-
-          while index < expr.length
-            char = expr[index]
-
-            if quote
-              quote = nil if char == quote
-            elsif ['"', "'"].include?(char)
-              quote = char
-            # `{`/`}` and `[`/`]` count toward depth like parens: an operator inside a
-            # block predicate (`.all? { |s| s.length > 0 }`) or array literal (`[0, 0 + 0]`)
-            # must not read as a split point for the enclosing expression.
-            elsif ["(", "{", "["].include?(char)
-              depth += 1
-            elsif [")", "}", "]"].include?(char)
-              depth -= 1
-            elsif depth.zero? && expr[index, operator.length] == operator
-              return index if !block_given? || yield(index)
-            end
-
-            index += 1
-          end
-          nil
-        end
       end
     end
   end

data/lib/hecks/bluebook/expression/resolver/block_predicates.rb

@@ -27,6 +27,10 @@ module Hecks
         # Every suffix that opens a `{ |x| ... }` block; `.find` builds a `Find`, not a mode.
         BLOCK_OPENER_SUFFIXES = (BLOCK_PREDICATE_MODES.keys + ["find"]).freeze
 
+        # Receiver text, suffix and block parameter of an opener, up to the first body character.
+        BLOCK_OPENER_PATTERN =
+          /\A(.+?)\.(#{BLOCK_OPENER_SUFFIXES.map { |suffix| Regexp.escape(suffix) }.join("|")})\s*\{\s*\|(\w+)\|\s*/m
+
         # `.all?`/`.any?`/`.none?`/`.find` — matched last among the suffix rules, before the
         # `Lookup` catch-all, since a block's predicate can contain almost any leaf expression.
         #
@@ -39,59 +43,39 @@ module Hecks
         # @return [Find, BlockPredicate, nil] the parsed node, or nil when `expr` does
         #   not open a `.all?`/`.any?`/`.none?`/`.find` block, or its brace never closes
         def parse_block_opener(expr)
-          pattern = /\A(.+?)\.(#{BLOCK_OPENER_SUFFIXES.map { |suffix| Regexp.escape(suffix) }.join('|')})\s*\{\s*\|(\w+)\|\s*/m
-          header = expr.match(pattern)
+          header = expr.match(BLOCK_OPENER_PATTERN)
           return nil unless header
 
-          receiver_text = header[1]
-          suffix = header[2]
-          param = header[3]
-          body_start = header.end(0)
-          body_end = matching_brace(expr, body_start)
+          body_end = matching_brace(expr, header.end(0))
           return nil unless body_end
 
-          predicate = Evaluator.parse(expr[body_start...body_end].strip)
+          predicate = Evaluator.parse(expr[header.end(0)...body_end].strip)
+          rest = expr[(body_end + 1)..].strip
+          return find_node(header, predicate, rest) if header[2] == "find"
 
-          if suffix == "find"
-            trailing = expr[(body_end + 1)..].strip
-            return nil unless trailing.empty? || trailing.start_with?(".")
+          block_predicate_node(header, predicate, rest)
+        end
 
-            Find.new(receiver: parse(receiver_text), param: param, predicate: predicate,
-                     path: trailing.empty? ? [] : trailing[1..].split("."))
-          else
-            return nil unless expr[(body_end + 1)..].strip.empty?
+        # @param header [MatchData] the opener match: receiver text, suffix, block parameter
+        # @param predicate [Object] the parsed block body
+        # @param rest [String] the text after the closing brace
+        # @return [Find, nil] the node, or nil unless `rest` is empty or a dotted path
+        def find_node(header, predicate, rest)
+          return nil unless rest.empty? || rest.start_with?(".")
 
-            BlockPredicate.new(mode: BLOCK_PREDICATE_MODES.fetch(suffix), receiver: parse(receiver_text),
-                               param: param, predicate: predicate)
-          end
+          Find.new(receiver: parse(header[1]), param: header[3], predicate: predicate,
+                   path: rest.empty? ? [] : rest[1..].split("."))
         end
 
-        # The index of the `}` closing the `{` the caller's header match already consumed
-        # (depth starts at 1). Quote-aware, so a `}` inside a quoted substring never counts.
-        #
-        # @param expr [String] the text to scan
-        # @param start [Integer] the index just after the opening `{`, where depth is 1
-        # @return [Integer, nil] the index of the matching `}`, or nil if `expr` runs
-        #   out before depth returns to 0
-        def matching_brace(expr, start)
-          depth = 1
-          quote = nil
-          index = start
-          while index < expr.length
-            char = expr[index]
-            if quote
-              quote = nil if char == quote
-            elsif ['"', "'"].include?(char)
-              quote = char
-            elsif char == "{"
-              depth += 1
-            elsif char == "}"
-              depth -= 1
-              return index if depth.zero?
-            end
-            index += 1
-          end
-          nil
+        # @param header [MatchData] the opener match: receiver text, suffix, block parameter
+        # @param predicate [Object] the parsed block body
+        # @param rest [String] the text after the closing brace
+        # @return [BlockPredicate, nil] the node, or nil unless the block ends `expr`
+        def block_predicate_node(header, predicate, rest)
+          return nil unless rest.empty?
+
+          BlockPredicate.new(mode: BLOCK_PREDICATE_MODES.fetch(header[2]), receiver: parse(header[1]),
+                             param: header[3], predicate: predicate)
         end
 
         # `.all?`/`.any?`/`.none?` over an already-interpreted `collection`: runs the

data/lib/hecks/bluebook/expression/resolver/lookups.rb

@@ -0,0 +1,77 @@
+# Name and path lookups of the `Resolver` leaf grammar: reading attributes and arguments, and
+# walking dotted paths through the values they hold.
+module Hecks
+  module Bluebook
+    module Expression
+      # Reopens `Resolver` (see resolver.rb) for lookups.
+      module Resolver
+        module_function
+
+        def lookup(expr, state, attrs)
+          return unwrap_scalar(fetch(expr, state, attrs)) unless expr.include?(".")
+
+          head, *rest = expr.split(".")
+          unwrap_scalar(walk_path(fetch(head, state, attrs), rest))
+        end
+
+        # Walks dotted segments through a Hash-like value. `key?` picks the symbol or string
+        # spelling so a held `false` is not mistaken for an absent key.
+        def walk_path(value, segments)
+          segments.reduce(value) do |current, segment|
+            break nil unless current.respond_to?(:[])
+
+            read_segment(current, segment)
+          end
+        end
+
+        def read_segment(current, segment)
+          if current.is_a?(Hash)
+            sym = segment.to_sym
+            return current.key?(sym) ? current[sym] : current[segment]
+          end
+
+          current[segment]
+        rescue TypeError
+          # `Array#[]` raises a raw TypeError for a String segment; refuse it instead.
+          raise EvaluationError, "cannot read #{segment.inspect} from #{describe(current)}"
+        end
+
+        # Unwraps a single-field value object to its scalar so `field == "literal"` works.
+        # Gated on the field count, not its name. Mirrors `impl Fielded for Json` in
+        # rust/src/kernel/json.rs; change both together.
+        def unwrap_scalar(value)
+          return value unless wrappable?(value)
+          return sole_field_of(value) if value.respond_to?(:value_object)
+
+          hash = value.to_h
+          hash.size == 1 && hash.key?(:value) ? hash[:value] : value
+        end
+
+        # Whether `value` is a record-like object (neither a Hash nor an Array) that converts
+        # to a Hash.
+        def wrappable?(value)
+          value.respond_to?(:to_h) && !value.is_a?(Hash) && !value.is_a?(Array)
+        end
+
+        def sole_field_of(value)
+          sole = value.value_object.sole_attribute
+          sole ? value[sole.name] : value
+        end
+
+        def fetch(name, state, attrs)
+          key = name.to_sym
+          return attrs[key] if attrs.key?(key)
+          return state[key] if known?(state, key)
+
+          raise EvaluationError, "cannot resolve #{name.inspect} — no such attribute or argument"
+        end
+
+        def known?(state, key)
+          return state.key?(key) if state.respond_to?(:key?)
+
+          !state[key].nil?
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/expression/resolver/operations.rb

@@ -0,0 +1,78 @@
+# What each `Resolver` node does to the value it resolves: the arithmetic, text and list
+# operations `interpret` applies, and the table that routes a node to its operation.
+module Hecks
+  module Bluebook
+    module Expression
+      # Reopens `Resolver` (see resolver.rb) for the operations `interpret` applies.
+      module Resolver
+        module_function
+
+        # Integer is signed 64-bit; a sum outside the range is an evaluation fault (C3.3, C3.4).
+        INT64_RANGE = (-(2**63))..((2**63) - 1)
+
+        # Each node that acts on one already-resolved receiver value, in the order they are tried.
+        # An operation is called as `(node, receiver_value, state, attrs)`.
+        RECEIVER_OPERATIONS = {
+          SignTest       => ->(node, value, _state, _attrs) { Resolver.apply_sign_test(node, value) },
+          Empty          => ->(_node, value, _state, _attrs) { Resolver.emptiness_of(value) },
+          ToS            => ->(_node, value, _state, _attrs) { Resolver.string_of(value) },
+          Modulo         => lambda { |node, value, state, attrs|
+            Resolver.apply_modulo(value, Resolver.interpret(node.divisor, state, attrs))
+          },
+          Size           => ->(_node, value, _state, _attrs) { Resolver.size_of(value) },
+          MatchesRegex   => ->(node, value, _state, _attrs) { Resolver.matches_regex?(value, node.pattern, node.flags) },
+          Presence       => ->(node, value, _state, _attrs) { Resolver.presence_of(node, value) },
+          Assignment     => ->(node, value, _state, _attrs) { Resolver.assignment_of(node, value) },
+          Split          => ->(node, value, _state, _attrs) { Resolver.split_value(value, node.separator) },
+          Last           => ->(_node, value, _state, _attrs) { Resolver.last_of(value) },
+          First          => ->(_node, value, _state, _attrs) { Resolver.first_of(value) },
+          Find           => ->(node, value, state, attrs) { Resolver.found_of(node, value, state, attrs) },
+          StartsWith     => ->(node, value, _state, _attrs) { Resolver.starts_with?(value, node.substring) },
+          EndsWith       => ->(node, value, _state, _attrs) { Resolver.ends_with?(value, node.substring) },
+          BlockPredicate => ->(node, value, state, attrs) { Resolver.evaluate_block_predicate(node, value, state, attrs) }
+        }.freeze
+
+        def add(left, right)
+          lhs = require_number(left, "addition")
+          rhs = require_number(right, "addition")
+          sum = lhs + rhs
+          if sum.is_a?(Integer)
+            return sum if INT64_RANGE.cover?(sum)
+
+            raise EvaluationError, "addition overflowed: #{lhs} + #{rhs} does not fit in a 64-bit integer"
+          end
+          return sum if sum.finite?
+
+          raise EvaluationError, "addition overflowed: #{lhs} + #{rhs} is not a finite number"
+        end
+
+        def apply_sign_test(node, value)
+          number = numeric(value)
+          raise EvaluationError, "#{node.test} expects a number, got #{describe(value)}" unless number
+
+          Evaluator.apply(node.operator, number, 0)
+        end
+
+        # The zero-check reads the coerced divisor, not the raw value or a `to_i` truncation.
+        def apply_modulo(receiver_value, divisor_value)
+          receiver = require_number(receiver_value, "modulo")
+          divisor  = require_number(divisor_value, "modulo")
+          raise EvaluationError, "divided by 0" if divisor.zero?
+
+          receiver % divisor
+        end
+
+        def numeric(value)
+          value if value.is_a?(Integer) || value.is_a?(Float)
+        end
+
+        def require_number(value, operation)
+          numeric(value) ||
+            raise(EvaluationError, "#{operation} expects a number, got #{describe(value)}")
+        end
+
+        def describe(value) = Rendering.describe(value)
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/expression/resolver/parsing.rb

@@ -0,0 +1,110 @@
+# Parsing of the `Resolver` leaf grammar: one step per leaf form, tried in precedence order.
+module Hecks
+  module Bluebook
+    module Expression
+      # Reopens `Resolver` (see resolver.rb) for `parse` and its steps.
+      module Resolver
+        module_function
+
+        # The suffix calls that wrap one receiver, each matched as `<receiver>.<suffix>`.
+        # A suffix naming a node class builds it over the receiver alone; a flag suffix also sets
+        # `negated`.
+        RECEIVER_SUFFIXES = [
+          [/\A(.+)\.empty\?\z/, Empty, {}], [/\A(.+)\.to_s\z/, ToS, {}], [/\A(.+)\.size\z/, Size, {}],
+          [/\A(.+)\.first\z/, First, {}], [/\A(.+)\.last\z/, Last, {}],
+          [/\A(.+)\.present\?\z/, Presence, { negated: false }], [/\A(.+)\.blank\?\z/, Presence, { negated: true }],
+          [/\A(.+)\.set\?\z/, Assignment, { negated: false }], [/\A(.+)\.unset\?\z/, Assignment, { negated: true }]
+        ].freeze
+
+        # The suffix calls that carry one quoted argument, as `<receiver>.<call>("<argument>")`.
+        TEXT_SUFFIXES = [
+          [/\A(.+)\.split\("([^"]*)"\)\z/, Split, :separator],
+          [/\A(.+)\.start_with\?\("([^"]*)"\)\z/, StartsWith, :substring],
+          [/\A(.+)\.end_with\?\("([^"]*)"\)\z/, EndsWith, :substring]
+        ].freeze
+
+        # Every step `parse` tries, in precedence order (`.length` first, sign tests before the
+        # rest); each answers a node, or `nil` when the expression is not its form.
+        PARSE_STEPS = [:parse_length, :parse_literal, :parse_array, :parse_addition, :parse_sign_test,
+                       :parse_receiver_suffix, :parse_modulo, :parse_matches_regex, :parse_text_suffix,
+                       :parse_block_opener].freeze
+
+        # @param expr [String] the leaf expression text
+        # @return [Object] the parsed leaf node, or `Lookup` when nothing else matches
+        def parse(expr)
+          expr = expr.to_s.strip
+
+          PARSE_STEPS.each do |step|
+            node = public_send(step, expr)
+            return node if node
+          end
+          Lookup.new(path: expr)
+        end
+
+        def parse_length(expr)
+          length = expr.match(/\A(.+)\.length\z/)
+          Size.new(receiver: parse(length[1])) if length
+        end
+
+        def parse_literal(expr)
+          return StringLiteral.new(value: expr[1..-2]) if quoted?(expr)
+
+          case expr
+          when /\A-?\d+\z/       then IntegerLiteral.new(value: Integer(expr, 10))
+          when /\A-?\d*\.\d+\z/  then FloatLiteral.new(value: Float(expr))
+          when "true", "false"   then BoolLiteral.new(value: expr == "true")
+          when "nil"             then NilLiteral.new
+          end
+        end
+
+        def parse_array(expr)
+          elements = array_elements(expr)
+          ArrayLiteral.new(elements: elements.map { |element| parse(element) }) if elements
+        end
+
+        def parse_addition(expr)
+          arithmetic = split_addition(expr)
+          Addition.new(left: parse(arithmetic[0]), right: parse(arithmetic[1])) if arithmetic
+        end
+
+        def parse_sign_test(expr)
+          sign = match_suffix(expr, SIGN_TESTS)
+          sign_test_node(sign) if sign
+        end
+
+        def parse_receiver_suffix(expr)
+          RECEIVER_SUFFIXES.each do |pattern, node_class, extra|
+            match = expr.match(pattern)
+            return node_class.new(receiver: parse(match[1]), **extra) if match
+          end
+          nil
+        end
+
+        def parse_modulo(expr)
+          modulo = match_call(expr, ".modulo(")
+          Modulo.new(receiver: parse(modulo[0]), divisor: parse(modulo[1])) if modulo
+        end
+
+        def parse_matches_regex(expr)
+          match = expr.match(%r{\A(.+)\.match\?\(/(.*)/([a-z]*)\)\z}m)
+          MatchesRegex.new(receiver: parse(match[1]), pattern: match[2], flags: match[3]) if match
+        end
+
+        def parse_text_suffix(expr)
+          TEXT_SUFFIXES.each do |pattern, node_class, field|
+            match = expr.match(pattern)
+            return node_class.new(receiver: parse(match[1]), field => match[2]) if match
+          end
+          nil
+        end
+
+        def sign_test_node(parts)
+          receiver, test = parts
+          symbol   = SIGN_TEST_OPERATORS.fetch(test)
+          operator = Evaluator::OPERATORS.find { |candidate| candidate.symbol == symbol }
+          SignTest.new(operator: operator, test: test, receiver: parse(receiver))
+        end
+      end
+    end
+  end
+end