astel 0.1.0

data/lib/astel/node_pattern/lexer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Astel
+  class NodePattern
+    class Lexer
+      SINGLE = { '(' => :lparen, ')' => :rparen, '{' => :lbrace, '}' => :rbrace,
+                 ':' => :colon, '$' => :capture }.freeze
+
+      def initialize(source)
+        @source = source
+        @index = 0
+        @line = 1
+        @column = 1
+      end
+
+      def tokens
+        result = []
+        loop do
+          skip_whitespace
+          break if eof?
+
+          result << next_token
+        end
+        result << Token.new(type: :eof, value: nil, line: @line, column: @column)
+        result
+      end
+
+      private
+
+      def next_token
+        line = @line
+        column = @column
+        character = current
+        single = SINGLE[character]
+        return token(single, advance, line, column) if single
+        return read_string(line, column) if ['"', "'"].include?(character)
+        return read_number(line, column) if character.match?(/[0-9-]/)
+        return read_identifier(line, column) if character.match?(/[A-Za-z_]/)
+
+        raise PatternError.new("unexpected character #{character.inspect}", line: line, column: column)
+      end
+
+      def read_string(line, column)
+        quote = advance
+        value = +''
+        until eof? || current == quote
+          if current == '\\'
+            advance
+            raise PatternError.new('unterminated escape', line: @line, column: @column) if eof?
+
+            escaped = advance
+            value << { 'n' => "\n", 'r' => "\r", 't' => "\t" }.fetch(escaped, escaped)
+          else
+            value << advance
+          end
+        end
+        raise PatternError.new('unterminated string', line: line, column: column) if eof?
+
+        advance
+        token(:literal, value.freeze, line, column)
+      end
+
+      def read_number(line, column)
+        start = @index
+        advance if current == '-'
+        advance while !eof? && current.match?(/[0-9]/)
+        text = @source[start...@index]
+        raise PatternError.new('invalid number', line: line, column: column) if text == '-'
+
+        token(:literal, Integer(text, 10), line, column)
+      end
+
+      def read_identifier(line, column)
+        start = @index
+        advance while !eof? && current.match?(/[A-Za-z0-9_?!]/)
+        value = @source[start...@index]
+        type = value == '_' ? :wildcard : :identifier
+        token(type, value, line, column)
+      end
+
+      def skip_whitespace
+        advance while !eof? && current.match?(/\s/)
+      end
+
+      def token(type, value, line, column)
+        Token.new(type: type, value: value, line: line, column: column)
+      end
+
+      def current
+        @source[@index]
+      end
+
+      def eof?
+        @index >= @source.length
+      end
+
+      def advance
+        character = current
+        @index += 1
+        if character == "\n"
+          @line += 1
+          @column = 1
+        else
+          @column += 1
+        end
+        character
+      end
+    end
+  end
+end

data/lib/astel/node_pattern/matcher_compiler.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Astel
+  class NodePattern
+    class MatcherCompiler
+      def compile(pattern)
+        @variable = 0
+        expression = result_expression(pattern, 'value')
+        eval("->(value) { #{expression} }", binding, __FILE__, __LINE__)
+      end
+
+      private
+
+      def result_expression(pattern, value)
+        if pattern.first == :or
+          return pattern.fetch(1).map do |alternative|
+            "(#{result_expression(alternative, value)})"
+          end.join(' || ')
+        end
+
+        condition, captures = branch_for(pattern, value)
+        "((#{condition}) ? [#{captures.join(', ')}] : nil)"
+      end
+
+      def branch_for(pattern, value)
+        type, *arguments = pattern
+        case type
+        when :literal then ["#{value} == #{arguments.fetch(0).inspect}", []]
+        when :wildcard then ["!#{value}.nil?", []]
+        when :capture then capture_branch(arguments.fetch(0), value)
+        when :or then or_branch(pattern, value)
+        when :node then node_branch(arguments.fetch(0), arguments.fetch(1), value)
+        else raise ArgumentError, "unknown pattern type: #{type}"
+        end
+      end
+
+      def capture_branch(pattern, value)
+        condition, captures = branch_for(pattern, value)
+        [condition, [value, *captures]]
+      end
+
+      def or_branch(pattern, value)
+        captures = next_variable('captures')
+        ["(#{captures} = #{result_expression(pattern, value)})", ["*#{captures}"]]
+      end
+
+      def node_branch(type, fields, value)
+        node_class = PredicateCompiler::NODE_CLASSES.fetch(type)
+        conditions = ["#{node_class.name} === #{value}"]
+        captures = []
+
+        fields.each do |name, field_pattern|
+          variable = next_variable('value')
+          condition, field_captures = branch_for(field_pattern, variable)
+          conditions << "((#{variable} = #{value}.#{name}); #{condition})"
+          captures.concat(field_captures)
+        end
+
+        [conditions.join(' && '), captures]
+      end
+
+      def next_variable(prefix)
+        @variable += 1
+        "#{prefix}_#{@variable}"
+      end
+    end
+  end
+end

data/lib/astel/node_pattern/parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Astel
+  class NodePattern
+    class Parser
+      def initialize(tokens)
+        @tokens = tokens
+        @index = 0
+      end
+
+      def parse
+        pattern = parse_pattern
+        error("unexpected token #{current.value.inspect}") unless current.type == :eof
+        pattern
+      end
+
+      private
+
+      def parse_pattern
+        return parse_node if accept(:lparen)
+        return parse_or if accept(:lbrace)
+        return [:capture, parse_pattern] if accept(:capture)
+        return [:wildcard] if accept(:wildcard)
+        return parse_symbol if accept(:colon)
+        return [:literal, previous.value] if accept(:literal)
+
+        return parse_identifier if accept(:identifier)
+
+        error('expected a pattern')
+      end
+
+      def parse_identifier
+        value = previous.value
+        return [:literal, nil] if value == 'nil'
+        return [:literal, true] if value == 'true'
+        return [:literal, false] if value == 'false'
+
+        [:literal, value.to_sym]
+      end
+
+      def parse_node
+        type = consume(:identifier, 'expected node type').value.to_sym
+        fields = []
+        until accept(:rparen)
+          error('unterminated node pattern') if current.type == :eof
+
+          name = consume(:identifier, 'expected attribute name').value.to_sym
+          consume(:colon, "expected ':' after attribute name")
+          fields << [name, parse_pattern]
+        end
+        [:node, type, fields.freeze]
+      end
+
+      def parse_or
+        alternatives = []
+        alternatives << parse_pattern until accept(:rbrace)
+        error('OR pattern must contain an alternative') if alternatives.empty?
+        [:or, alternatives.freeze]
+      end
+
+      def parse_symbol
+        value = consume(:identifier, 'expected symbol name').value
+        [:literal, value.to_sym]
+      end
+
+      def accept(type)
+        return false unless current.type == type
+
+        @index += 1
+        true
+      end
+
+      def consume(type, message)
+        token = current
+        error(message) unless accept(type)
+        token
+      end
+
+      def current
+        @tokens[@index]
+      end
+
+      def previous
+        @tokens[@index - 1]
+      end
+
+      def error(message)
+        raise PatternError.new(message, line: current.line, column: current.column)
+      end
+    end
+  end
+end

data/lib/astel/node_pattern/predicate_compiler.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Astel
+  class NodePattern
+    class PredicateCompiler
+      NODE_CLASSES = Prism.constants.filter_map do |constant|
+        value = Prism.const_get(constant)
+        next unless value.is_a?(Class) && value < Prism::Node
+
+        type = NodeType.from_class_name(constant.to_s)
+        [type, value]
+      rescue NameError
+        nil
+      end.to_h.freeze
+
+      def compile(pattern)
+        @variable = 0
+        expression = expression_for(pattern, 'value')
+        eval("->(value) { #{expression} }", binding, __FILE__, __LINE__)
+      end
+
+      private
+
+      def expression_for(pattern, value)
+        type, *arguments = pattern
+        case type
+        when :literal then "#{value} == #{arguments.fetch(0).inspect}"
+        when :wildcard then "!#{value}.nil?"
+        when :capture then expression_for(arguments.fetch(0), value)
+        when :or then or_expression(arguments.fetch(0), value)
+        when :node then node_expression(arguments.fetch(0), arguments.fetch(1), value)
+        else raise ArgumentError, "unknown pattern type: #{type}"
+        end
+      end
+
+      def or_expression(alternatives, value)
+        alternatives.map { |alternative| "(#{expression_for(alternative, value)})" }.join(' || ')
+      end
+
+      def node_expression(type, fields, value)
+        node_class = NODE_CLASSES[type]
+        raise PatternError.new("unknown Prism node type #{type}", line: 1, column: 1) unless node_class
+
+        conditions = ["#{node_class.name} === #{value}"]
+        fields.each do |name, pattern|
+          unless node_class.method_defined?(name)
+            raise PatternError.new("unknown #{type} attribute #{name}", line: 1, column: 1)
+          end
+
+          variable = next_variable
+          conditions << "((#{variable} = #{value}.#{name}); #{expression_for(pattern, variable)})"
+        end
+        conditions.join(' && ')
+      end
+
+      def next_variable
+        @variable += 1
+        "value_#{@variable}"
+      end
+    end
+  end
+end

data/lib/astel/node_pattern.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Astel
+  class NodePattern
+    COMPILER_CACHE_LIMIT = 128
+    COMPILER_CACHE = {}
+    COMPILER_CACHE_MUTEX = Mutex.new
+    private_constant :COMPILER_CACHE, :COMPILER_CACHE_MUTEX
+
+    class PatternError < Error
+      attr_reader :line, :column
+
+      def initialize(message, line:, column:)
+        @line = line
+        @column = column
+        super("#{message} at line #{line}, column #{column}")
+      end
+    end
+
+    Token = Data.define(:type, :value, :line, :column)
+  end
+end
+
+require_relative 'node_pattern/lexer'
+require_relative 'node_pattern/parser'
+require_relative 'node_pattern/matcher_compiler'
+require_relative 'node_pattern/predicate_compiler'
+
+module Astel
+  class NodePattern
+    module CaptureMatching
+      def match(node)
+        captures = match_captures(node)
+        return unless captures
+
+        yield captures if block_given?
+        captures
+      end
+    end
+
+    def self.compile(source)
+      predicate, matcher = compiled_matchers(source)
+      new(predicate, matcher)
+    end
+
+    def self.compiled_matchers(source)
+      COMPILER_CACHE_MUTEX.synchronize do
+        cached = COMPILER_CACHE[source]
+        return cached if cached
+
+        tokens = Lexer.new(source).tokens
+        syntax = Parser.new(tokens).parse
+        predicate = PredicateCompiler.new.compile(syntax)
+        matcher = MatcherCompiler.new.compile(syntax) if captures?(syntax)
+        COMPILER_CACHE.shift if COMPILER_CACHE.length >= COMPILER_CACHE_LIMIT
+        COMPILER_CACHE[source.dup.freeze] = [predicate, matcher].freeze
+      end
+    end
+    private_class_method :compiled_matchers
+
+    def initialize(predicate, matcher)
+      define_singleton_method(:match?, predicate)
+      return unless matcher
+
+      define_singleton_method(:match_captures, matcher)
+      singleton_class.send(:private, :match_captures)
+      extend CaptureMatching
+    end
+
+    def match(node)
+      return unless match?(node)
+
+      captures = []
+      yield captures if block_given?
+      captures
+    end
+
+    def self.captures?(pattern)
+      type, *arguments = pattern
+      return true if type == :capture
+      return arguments.fetch(0).any? { |alternative| captures?(alternative) } if type == :or
+      return arguments.fetch(1).any? { |_name, field_pattern| captures?(field_pattern) } if type == :node
+
+      false
+    end
+    private_class_method :captures?
+  end
+end

data/lib/astel/node_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Astel
+  module NodeType
+    module_function
+
+    def from_class_name(name)
+      name.gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')
+          .gsub(/([a-z\d])([A-Z])/, '\\1_\\2')
+          .downcase
+          .to_sym
+    end
+  end
+end

data/lib/astel/rewriter.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Astel
+  class Rewriter
+    class ConflictError < Error
+      attr_reader :edit, :conflicting_edit
+
+      def initialize(edit, conflicting_edit)
+        @edit = edit
+        @conflicting_edit = conflicting_edit
+        super("edit #{edit.start_offset}...#{edit.end_offset} conflicts with " \
+              "#{conflicting_edit.start_offset}...#{conflicting_edit.end_offset}")
+      end
+    end
+
+    Edit = Data.define(:start_offset, :end_offset, :replacement, :sequence) do
+      def insertion?
+        start_offset == end_offset
+      end
+    end
+
+    class EditIndex
+      include Enumerable
+
+      SPLIT_THRESHOLD = 256
+
+      def initialize
+        @blocks = []
+      end
+
+      def add(edit)
+        if @blocks.empty?
+          @blocks << [edit]
+          return
+        end
+
+        block_index = block_index_for(edit)
+        block = @blocks.fetch(block_index)
+        edit_index = block.bsearch_index { |existing| ordered_after?(existing, edit) } || block.length
+        following = block[edit_index] || @blocks[block_index + 1]&.first
+        return following if following && yield(following)
+
+        preceding = if edit_index.positive?
+                      block[edit_index - 1]
+                    elsif block_index.positive?
+                      @blocks[block_index - 1].last
+                    end
+        return preceding if preceding && yield(preceding)
+
+        block.insert(edit_index, edit)
+        split(block_index, block) if block.length > SPLIT_THRESHOLD
+        nil
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @blocks.each do |block|
+          block.each { |edit| yield edit }
+        end
+      end
+
+      private
+
+      def block_index_for(edit)
+        @blocks.bsearch_index { |block| ordered_after?(block.last, edit) } || @blocks.length - 1
+      end
+
+      def ordered_after?(existing, edit)
+        existing.start_offset > edit.start_offset ||
+          (existing.start_offset == edit.start_offset && existing.end_offset > edit.end_offset) ||
+          (existing.start_offset == edit.start_offset && existing.end_offset == edit.end_offset &&
+           existing.sequence > edit.sequence)
+      end
+
+      def split(block_index, block)
+        middle = block.length / 2
+        @blocks.insert(block_index + 1, block.slice!(middle, block.length - middle))
+      end
+    end
+
+    def initialize(source_file)
+      @source_file = source_file
+      @edits = []
+      @edits_snapshot = nil
+      @edit_index = EditIndex.new
+      @sequence = 0
+      @result_size_delta = 0
+    end
+
+    def edits
+      @edits_snapshot ||= @edits.dup.freeze
+    end
+
+    def replace(location, replacement)
+      start_offset, end_offset = offsets(location)
+      add_edit(start_offset, end_offset, replacement)
+    end
+
+    def insert_before(location, content)
+      start_offset, = offsets(location)
+      add_edit(start_offset, start_offset, content)
+    end
+
+    def insert_after(location, content)
+      _, end_offset = offsets(location)
+      add_edit(end_offset, end_offset, content)
+    end
+
+    def remove(location)
+      replace(location, '')
+    end
+
+    def rewrite
+      source = @source_file.source
+      result = String.new(capacity: source.bytesize + @result_size_delta, encoding: source.encoding)
+      cursor = 0
+
+      @edit_index.each do |edit|
+        result << source.byteslice(cursor, edit.start_offset - cursor)
+        result << edit.replacement
+        cursor = edit.end_offset
+      end
+
+      result << source.byteslice(cursor, source.bytesize - cursor)
+      result
+    end
+
+    private
+
+    def add_edit(start_offset, end_offset, replacement)
+      validate_offsets(start_offset, end_offset)
+      edit = Edit.new(
+        start_offset: start_offset,
+        end_offset: end_offset,
+        replacement: replacement.to_s.dup.freeze,
+        sequence: @sequence
+      )
+      conflict = @edit_index.add(edit) { |existing| conflict?(edit, existing) }
+      raise ConflictError.new(edit, conflict) if conflict
+
+      @sequence += 1
+      @result_size_delta += edit.replacement.bytesize - (edit.end_offset - edit.start_offset)
+      @edits << edit
+      @edits_snapshot = nil
+      self
+    end
+
+    def offsets(location)
+      if location.is_a?(Range)
+        ending = location.exclude_end? ? location.end : location.end + 1
+        return [location.begin, ending]
+      end
+      [location.start_offset, location.end_offset]
+    end
+
+    def validate_offsets(start_offset, end_offset)
+      valid = start_offset.is_a?(Integer) && end_offset.is_a?(Integer) &&
+              start_offset >= 0 && start_offset <= end_offset && end_offset <= @source_file.source.bytesize
+      raise RangeError, 'edit range is outside the source' unless valid
+    end
+
+    def conflict?(left, right)
+      return left.start_offset == right.start_offset if left.insertion? && right.insertion?
+      return left.start_offset > right.start_offset && left.start_offset < right.end_offset if left.insertion?
+      return right.start_offset > left.start_offset && right.start_offset < left.end_offset if right.insertion?
+
+      left.start_offset < right.end_offset && right.start_offset < left.end_offset
+    end
+  end
+end

data/lib/astel/source_file.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Astel
+  class SourceFile
+    attr_reader :path, :source, :ast, :comments, :errors, :parse_result
+
+    def self.parse(path:, version: nil)
+      from_string(File.binread(path), path: path, version: version)
+    end
+
+    def self.from_string(code, path: '(string)', version: nil)
+      new(code, path: path, version: version)
+    end
+
+    def initialize(code, path:, version: nil)
+      @path = path.to_s.freeze
+      raw_source = code.dup.freeze
+      options = { filepath: @path }
+      options[:version] = normalize_version(version) if version
+      @parse_result = Prism.parse(raw_source, **options)
+      @source = @parse_result.source.source.freeze
+      @ast = @parse_result.value
+      @comments = @parse_result.comments.freeze
+      @errors = @parse_result.errors.freeze
+      @lines = nil
+    end
+
+    def lines
+      @lines ||= source.lines(chomp: false).map!(&:freeze).freeze
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def bof
+      Location.point(offset: 0, line: 1, column: 0)
+    end
+
+    def first_line_location
+      line = lines.first || ''
+      Location.new(
+        start_offset: 0,
+        end_offset: line.bytesize,
+        start_line: 1,
+        start_column: 0,
+        end_line: 1,
+        end_column: line.delete_suffix("\n").delete_suffix("\r").length
+      )
+    end
+
+    def magic_comment?(name)
+      pattern = /\A#\s*#{Regexp.escape(name.to_s)}\s*:\s*true\b/
+      lines.first(2).any? do |line|
+        candidate = line.start_with?("\uFEFF") ? line.delete_prefix("\uFEFF") : line
+        candidate.match?(pattern)
+      end
+    end
+
+    private
+
+    def normalize_version(version)
+      version.match?(/\A\d+\.\d+\z/) ? "#{version}.0" : version
+    end
+  end
+end

data/lib/astel/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Astel
+  VERSION = '0.1.0'
+end

data/lib/astel.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'astel/version'
+
+module Astel
+  class Error < StandardError; end
+
+  autoload :Location, File.expand_path('astel/location', __dir__)
+  autoload :SourceFile, File.expand_path('astel/source_file', __dir__)
+  autoload :NodeExt, File.expand_path('astel/node_ext', __dir__)
+  autoload :NodeType, File.expand_path('astel/node_type', __dir__)
+  autoload :Dispatcher, File.expand_path('astel/dispatcher', __dir__)
+  autoload :NodePattern, File.expand_path('astel/node_pattern', __dir__)
+  autoload :Rewriter, File.expand_path('astel/rewriter', __dir__)
+end