evilution 0.16.1 → 0.18.0

data/lib/evilution/ast/pattern/parser.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative "matcher"
+
+class Evilution::AST::Pattern::Parser
+  def initialize(input)
+    @input = input.strip
+    @pos = 0
+  end
+
+  def parse
+    raise Evilution::ConfigError, "invalid pattern: empty string" if @input.empty?
+
+    result = parse_pattern
+    skip_whitespace
+    raise Evilution::ConfigError, "unexpected characters at position #{@pos}: #{@input[@pos..]}" unless @pos >= @input.length
+
+    result
+  end
+
+  private
+
+  def parse_pattern
+    skip_whitespace
+
+    if peek_string("**")
+      advance(2)
+      Evilution::AST::Pattern::DeepWildcardMatcher.new
+    elsif current_char == "_" && !identifier_continues?(1)
+      advance(1)
+      Evilution::AST::Pattern::AnyNodeMatcher.new
+    else
+      parse_node_pattern
+    end
+  end
+
+  def parse_node_pattern
+    node_type = consume_identifier
+    skip_whitespace
+
+    attributes = {}
+    if current_char == "{"
+      advance(1)
+      attributes = parse_attributes
+      skip_whitespace
+      expect_char("}")
+    end
+
+    Evilution::AST::Pattern::NodeMatcher.new(node_type, attributes)
+  end
+
+  def parse_attributes
+    attrs = {}
+    skip_whitespace
+
+    return attrs if current_char == "}"
+
+    loop do
+      skip_whitespace
+      name = consume_identifier
+      skip_whitespace
+      expect_char("=", "expected '=' after attribute name '#{name}'")
+      skip_whitespace
+      value = parse_value
+      attrs[name] = value
+      skip_whitespace
+
+      break unless current_char == ","
+
+      advance(1)
+    end
+
+    attrs
+  end
+
+  def parse_value
+    skip_whitespace
+
+    if current_char == "!"
+      advance(1)
+      skip_whitespace
+      inner = parse_value
+      Evilution::AST::Pattern::NegationMatcher.new(inner)
+    elsif current_char == "*" && !peek_string("**")
+      advance(1)
+      Evilution::AST::Pattern::WildcardValueMatcher.new
+    elsif peek_string("**")
+      advance(2)
+      Evilution::AST::Pattern::DeepWildcardMatcher.new
+    elsif current_char == "_" && !identifier_continues?(1)
+      advance(1)
+      Evilution::AST::Pattern::AnyNodeMatcher.new
+    else
+      parse_value_or_nested
+    end
+  end
+
+  def parse_value_or_nested
+    id = consume_identifier
+    skip_whitespace
+
+    if current_char == "{"
+      advance(1)
+      attrs = parse_attributes
+      skip_whitespace
+      expect_char("}")
+      Evilution::AST::Pattern::NodeMatcher.new(id, attrs)
+    else
+      parse_alternatives_from(id)
+    end
+  end
+
+  def parse_alternatives_from(first)
+    values = [first]
+
+    while current_char == "|"
+      advance(1)
+      skip_whitespace
+      if current_char == "*" && !peek_string("**")
+        advance(1)
+        values << "*"
+      else
+        values << consume_identifier
+      end
+    end
+
+    if values.length == 1
+      Evilution::AST::Pattern::ValueMatcher.new(first)
+    else
+      Evilution::AST::Pattern::AlternativesMatcher.new(values)
+    end
+  end
+
+  def consume_identifier
+    raise Evilution::ConfigError, "unexpected end of pattern at position #{@pos}" if current_char.nil?
+
+    unless current_char.match?(/[a-zA-Z_]/)
+      raise Evilution::ConfigError, "invalid identifier starting with '#{current_char}' at position #{@pos}"
+    end
+
+    start = @pos
+    advance(1)
+    advance(1) while @pos < @input.length && @input[@pos].match?(/[a-zA-Z0-9_]/)
+
+    @input[start...@pos]
+  end
+
+  def skip_whitespace
+    advance(1) while @pos < @input.length && @input[@pos] == " "
+  end
+
+  def current_char
+    @pos < @input.length ? @input[@pos] : nil
+  end
+
+  def peek_string(str)
+    @input[@pos, str.length] == str
+  end
+
+  def identifier_continues?(offset)
+    char = @input[@pos + offset]
+    char && char.match?(/[a-zA-Z0-9_]/)
+  end
+
+  def advance(n)
+    @pos += n
+  end
+
+  def expect_char(char, message = nil)
+    current = current_char
+
+    if current == char
+      advance(1)
+      return
+    end
+
+    if current.nil?
+      raise Evilution::ConfigError,
+            (message || "unexpected end of pattern, expected '#{char}' at position #{@pos}")
+    else
+      raise Evilution::ConfigError,
+            (message || "unexpected character '#{current}', expected '#{char}' at position #{@pos}")
+    end
+  end
+end

data/lib/evilution/ast/pattern.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Evilution::AST::Pattern
+end

data/lib/evilution/ast/sorbet_sig_detector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "prism"
+
+class Evilution::AST::SorbetSigDetector
+  def call(source)
+    return [] if source.empty?
+
+    result = Prism.parse(source)
+    return [] if result.failure?
+
+    ranges = []
+    collect_sig_ranges(result.value, ranges, :byte)
+    ranges
+  end
+
+  def line_ranges(source)
+    return [] if source.empty?
+
+    result = Prism.parse(source)
+    return [] if result.failure?
+
+    ranges = []
+    collect_sig_ranges(result.value, ranges, :line)
+    ranges
+  end
+
+  private
+
+  def collect_sig_ranges(node, ranges, mode)
+    if sig_block?(node)
+      loc = node.location
+      ranges << if mode == :byte
+                  (loc.start_offset...loc.end_offset)
+                else
+                  (loc.start_line..loc.end_line)
+                end
+    end
+
+    node.child_nodes.each do |child|
+      collect_sig_ranges(child, ranges, mode) if child
+    end
+  end
+
+  def sig_block?(node)
+    node.is_a?(Prism::CallNode) &&
+      node.name == :sig &&
+      node.receiver.nil? &&
+      node.arguments.nil? &&
+      !node.block.nil?
+  end
+end