astel 0.1.0 → 0.3.0

data/lib/astel/node_ext.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-require 'prism'
+require_relative 'node_source_text'
 
 module Astel
-  module NodeExt
-    refine Prism::Node do
-      def source_text
-        location.slice
-      end
-    end
-  end
+  NodeExt = NodeSourceText
 end

data/lib/astel/node_pattern/lexer.rb

@@ -5,6 +5,7 @@ module Astel
     class Lexer
       SINGLE = { '(' => :lparen, ')' => :rparen, '{' => :lbrace, '}' => :rbrace,
                  ':' => :colon, '$' => :capture }.freeze
+      OPERATOR_CHARACTERS = '+-*/%<>=~&|^![]@`'.freeze
 
       def initialize(source)
         @source = source
@@ -34,8 +35,9 @@ module Astel
         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_]/)
+        return read_number(line, column) if number_start?(character)
+        return read_identifier(line, column) if identifier_start?(character)
+        return read_operator(line, column) if OPERATOR_CHARACTERS.include?(character)
 
         raise PatternError.new("unexpected character #{character.inspect}", line: line, column: column)
       end
@@ -44,15 +46,7 @@ module Astel
         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
+          value << (current == '\\' ? read_escaped_character : advance)
         end
         raise PatternError.new('unterminated string', line: line, column: column) if eof?
 
@@ -60,6 +54,14 @@ module Astel
         token(:literal, value.freeze, line, column)
       end
 
+      def read_escaped_character
+        advance
+        raise PatternError.new('unterminated escape', line: @line, column: @column) if eof?
+
+        escaped = advance
+        { 'n' => "\n", 'r' => "\r", 't' => "\t" }.fetch(escaped, escaped)
+      end
+
       def read_number(line, column)
         start = @index
         advance if current == '-'
@@ -72,12 +74,31 @@ module Astel
 
       def read_identifier(line, column)
         start = @index
-        advance while !eof? && current.match?(/[A-Za-z0-9_?!]/)
+        advance while !eof? && identifier_character?(current)
+        advance if !eof? && current == '='
         value = @source[start...@index]
         type = value == '_' ? :wildcard : :identifier
         token(type, value, line, column)
       end
 
+      def read_operator(line, column)
+        start = @index
+        advance while !eof? && OPERATOR_CHARACTERS.include?(current)
+        token(:identifier, @source[start...@index], line, column)
+      end
+
+      def number_start?(character)
+        character.match?(/[0-9]/) || (character == '-' && @source[@index + 1]&.match?(/[0-9]/))
+      end
+
+      def identifier_start?(character)
+        character.match?(/[[:alpha:]_]/)
+      end
+
+      def identifier_character?(character)
+        character.match?(/[[:alnum:]_?!]/)
+      end
+
       def skip_whitespace
         advance while !eof? && current.match?(/\s/)
       end

data/lib/astel/node_pattern/matcher_compiler.rb

@@ -50,15 +50,20 @@ module Astel
         captures = []
 
         fields.each do |name, field_pattern|
-          variable = next_variable('value')
-          condition, field_captures = branch_for(field_pattern, variable)
-          conditions << "((#{variable} = #{value}.#{name}); #{condition})"
+          condition, field_captures = field_branch(name, field_pattern, value)
+          conditions << condition
           captures.concat(field_captures)
         end
 
         [conditions.join(' && '), captures]
       end
 
+      def field_branch(name, pattern, value)
+        variable = next_variable('value')
+        condition, captures = branch_for(pattern, variable)
+        ["((#{variable} = #{value}.#{name}); #{condition})", captures]
+      end
+
       def next_variable(prefix)
         @variable += 1
         "#{prefix}_#{@variable}"

data/lib/astel/node_pattern/parser.rb

@@ -39,16 +39,21 @@ module Astel
       end
 
       def parse_node
-        type = consume(:identifier, 'expected node type').value.to_sym
+        token = consume(:identifier, 'expected node type')
+        type = token.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]
+          fields << parse_field
         end
-        [:node, type, fields.freeze]
+        [:node, type, fields.freeze, token.line, token.column]
+      end
+
+      def parse_field
+        token = consume(:identifier, 'expected attribute name')
+        name = token.value.to_sym
+        consume(:colon, "expected ':' after attribute name")
+        [name, parse_pattern, token.line, token.column]
       end
 
       def parse_or
@@ -59,8 +64,11 @@ module Astel
       end
 
       def parse_symbol
-        value = consume(:identifier, 'expected symbol name').value
-        [:literal, value.to_sym]
+        token = current
+        unless accept(:identifier) || accept(:wildcard) || (token.type == :literal && token.value.is_a?(String) && accept(:literal))
+          error('expected symbol name')
+        end
+        [:literal, token.value.to_sym]
       end
 
       def accept(type)

data/lib/astel/node_pattern/predicate_compiler.rb

@@ -28,7 +28,9 @@ module Astel
         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)
+        when :node
+          node_expression(arguments.fetch(0), arguments.fetch(1), value,
+                          line: arguments.fetch(2), column: arguments.fetch(3))
         else raise ArgumentError, "unknown pattern type: #{type}"
         end
       end
@@ -37,22 +39,34 @@ module Astel
         alternatives.map { |alternative| "(#{expression_for(alternative, value)})" }.join(' || ')
       end
 
-      def node_expression(type, fields, value)
+      def node_expression(type, fields, value, line:, column:)
         node_class = NODE_CLASSES[type]
-        raise PatternError.new("unknown Prism node type #{type}", line: 1, column: 1) unless node_class
+        raise PatternError.new("unknown Prism node type #{type}", line: line, column: column) 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)})"
+        fields.each do |name, pattern, field_line, field_column|
+          conditions << field_condition(
+            node_class, type, name, pattern, value,
+            line: field_line, column: field_column
+          )
         end
         conditions.join(' && ')
       end
 
+      def field_condition(node_class, type, name, pattern, value, line:, column:)
+        unless node_attribute?(node_class, name)
+          raise PatternError.new("unknown #{type} attribute #{name}", line: line, column: column)
+        end
+
+        variable = next_variable
+        "((#{variable} = #{value}.#{name}); #{expression_for(pattern, variable)})"
+      end
+
+      def node_attribute?(node_class, name)
+        fields = node_class.instance_method(:copy).parameters.map(&:last) - %i[node_id flags]
+        fields.include?(name) || (name.to_s.end_with?('?') && node_class.instance_methods(false).include?(name))
+      end
+
       def next_variable
         @variable += 1
         "value_#{@variable}"

data/lib/astel/node_pattern.rb

@@ -50,23 +50,23 @@ module Astel
         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
+        COMPILER_CACHE[source.dup.freeze] = compile_matchers(source)
       end
     end
     private_class_method :compiled_matchers
 
+    def self.compile_matchers(source)
+      syntax = Parser.new(Lexer.new(source).tokens).parse
+      predicate = PredicateCompiler.new.compile(syntax)
+      matcher = MatcherCompiler.new.compile(syntax) if captures?(syntax)
+      [predicate, matcher].freeze
+    end
+    private_class_method :compile_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
+      install_capture_matcher(matcher) if matcher
     end
 
     def match(node)
@@ -77,6 +77,14 @@ module Astel
       captures
     end
 
+    private
+
+    def install_capture_matcher(matcher)
+      define_singleton_method(:match_captures, matcher)
+      singleton_class.send(:private, :match_captures)
+      extend CaptureMatching
+    end
+
     def self.captures?(pattern)
       type, *arguments = pattern
       return true if type == :capture

data/lib/astel/node_source_text.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Astel
+  module NodeSourceText
+    refine Prism::Node do
+      def source_text
+        location.slice
+      end
+    end
+  end
+end

data/lib/astel/refactor.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'rewriter/structured'
+
+module Astel
+  Refactor = Rewriter.const_get(:Structured, false)
+end

data/lib/astel/rewriter/edit_index.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Astel
+  class Rewriter
+    class EditIndex
+      include Enumerable
+
+      SPLIT_THRESHOLD = 256
+
+      def initialize
+        @blocks = []
+      end
+
+      def add(edit)
+        if @blocks.empty?
+          @blocks << [edit]
+          return
+        end
+
+        block_index, block, edit_index = insertion_position(edit)
+        conflict = conflict_at(block_index, block, edit_index) { |existing| yield existing }
+        return conflict if conflict
+
+        block.insert(edit_index, edit)
+        split(block_index, block) if block.length > SPLIT_THRESHOLD
+        nil
+      end
+
+      def find_conflict(edit)
+        return if @blocks.empty?
+
+        block_index, block, edit_index = insertion_position(edit)
+        conflict_at(block_index, block, edit_index) { |existing| yield existing }
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @blocks.each do |block|
+          block.each { |edit| yield edit }
+        end
+      end
+
+      private
+
+      def insertion_position(edit)
+        block_index = block_index_for(edit)
+        block = @blocks.fetch(block_index)
+        edit_index = block.bsearch_index { |existing| ordered_after?(existing, edit) } || block.length
+        [block_index, block, edit_index]
+      end
+
+      def conflict_at(block_index, block, edit_index)
+        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)
+
+        nil
+      end
+
+      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
+  end
+end

data/lib/astel/rewriter/structured/collections.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Astel
+  class Rewriter
+    module Structured
+      def remove_list_element(collection_node, element_node)
+        remove_list_elements(collection_node, [element_node])
+      end
+
+      def remove_list_elements(collection_node, element_nodes)
+        elements = collection_elements(collection_node)
+        indexes = element_indexes(elements, element_nodes)
+        return self if indexes.empty?
+
+        trailing_end = trailing_comma_end(elements.last)
+        start_offset = elements.first.location.start_offset
+        content = content_without_elements(
+          elements, indexes, start_offset: start_offset, end_offset: trailing_end
+        )
+        extra_ranges = indexes.flat_map { |index| heredoc_ranges(elements[index]) }
+        return replace(start_offset...trailing_end, content) if extra_ranges.empty?
+
+        transaction(raise_on_conflict: true) do |rewriter|
+          rewriter.replace(start_offset...trailing_end, content)
+          extra_ranges.each { |range| rewriter.remove(range) }
+        end
+        self
+      end
+
+      def insert_list_element(collection_node, index, text)
+        elements = collection_elements(collection_node)
+        raise IndexError, 'list index is outside the collection' unless index.between?(0, elements.length)
+
+        if elements.empty?
+          opening = collection_node.respond_to?(:opening_loc) && collection_node.opening_loc
+          raise ArgumentError, 'cannot locate an empty collection body' unless opening
+
+          return insert_into_empty_delimited(collection_node, text)
+        end
+
+        if index < elements.length
+          target = elements[index]
+          return insert_before(target.location, "#{text}#{list_separator(collection_node, target)}")
+        end
+
+        last = elements.last
+        insert_after(last.location, "#{list_separator(collection_node, last)}#{text}")
+      end
+
+      private
+
+      def element_indexes(elements, element_nodes)
+        element_nodes.map do |element|
+          elements.index { |candidate| candidate.equal?(element) } ||
+            raise(ArgumentError, 'element does not belong to collection')
+        end.uniq.sort
+      end
+
+      def content_without_elements(elements, indexes, start_offset:, end_offset:)
+        content = @source_file.source.byteslice(start_offset, end_offset - start_offset).b
+        deletion_ranges(elements, indexes, end_offset).reverse_each do |from, to, replacement|
+          content.bytesplice(from - start_offset, to - from, replacement.b)
+        end
+        content.force_encoding(@source_file.source.encoding)
+      end
+
+      def list_separator(collection_node, adjacent_element)
+        separator = percent_list?(collection_node) ? '' : ','
+        return "#{separator} " unless multiline_collection?(collection_node)
+
+        "#{separator}#{@source_file.newline}#{indentation_of(adjacent_element)}"
+      end
+
+      def collection_elements(collection_node)
+        case collection_node
+        when Prism::ArgumentsNode then collection_node.arguments
+        when Prism::ArrayNode, Prism::KeywordHashNode, Prism::HashNode then collection_node.elements
+        else
+          raise ArgumentError, 'collection must be an arguments, array, or hash node'
+        end
+      end
+
+      def deletion_ranges(elements, indexes, trailing_end)
+        removed = indexes.to_h { |index| [index, true] }
+        indexes.slice_when { |left, right| right != left + 1 }.map do |group|
+          deletion_range(elements, group, removed, trailing_end)
+        end
+      end
+
+      def deletion_range(elements, group, removed, trailing_end)
+        first = group.first
+        last = group.last
+        following = ((last + 1)...elements.length).find { |index| !removed[index] }
+        return [elements[first].location.start_offset, elements[following].location.start_offset, ''] if following
+
+        preceding = (first - 1).downto(0).find { |index| !removed[index] }
+        return [elements.first.location.start_offset, trailing_end, ''] unless preceding
+
+        from = elements[preceding].location.end_offset
+        has_trailing_comma = last == elements.length - 1 && trailing_end > elements.last.location.end_offset
+        to = has_trailing_comma ? trailing_end : elements[last].location.end_offset
+        between = @source_file.source.byteslice(from, elements[first].location.start_offset - from)
+        replacement = tail_deletion_replacement(
+          between,
+          trailing_comma: has_trailing_comma,
+          line_break_follows: line_break_follows?(to)
+        )
+        [from, to, replacement]
+      end
+
+      def tail_deletion_replacement(separator, trailing_comma:, line_break_follows:)
+        replacement = if trailing_comma
+                        separator.include?('#') ? trim_trailing_horizontal_space(separator) : ','
+                      elsif separator.include?('#')
+                        trim_trailing_horizontal_space(separator.sub(',', ''))
+                      else
+                        return ''
+                      end
+        line_break_follows ? replacement.delete_suffix("\r\n").delete_suffix("\n") : replacement
+      end
+
+      def line_break_follows?(offset)
+        source = @source_file.source
+        offset += 1 while [32, 9].include?(source.getbyte(offset))
+        [10, 13].include?(source.getbyte(offset))
+      end
+
+      def trailing_comma_end(element)
+        offset = element.location.end_offset
+        source = @source_file.source
+        offset += 1 while [32, 9].include?(source.getbyte(offset))
+        source.getbyte(offset) == 44 ? offset + 1 : element.location.end_offset
+      end
+
+      def multiline_collection?(collection_node)
+        return true if @source_file.slice(collection_node.location).include?("\n")
+
+        start_offset = collection_node.location.start_offset
+        prefix = @source_file.source.byteslice(@source_file.line_start(start_offset),
+                                               start_offset - @source_file.line_start(start_offset))
+        collection_node.is_a?(Prism::KeywordHashNode) && !prefix.empty? && prefix.strip.empty?
+      end
+
+      def percent_list?(collection_node)
+        collection_node.is_a?(Prism::ArrayNode) &&
+          collection_node.opening_loc&.slice&.match?(/\A%[wWiI]/)
+      end
+
+      def trim_trailing_horizontal_space(text)
+        text.sub(/[ \t]+\z/, '')
+      end
+
+      def insert_into_empty_delimited(node, text)
+        opening = node.opening_loc
+        closing = node.closing_loc
+        return insert_after(opening, text) unless closing
+
+        source = @source_file.source
+        interior = source.byteslice(opening.end_offset, closing.start_offset - opening.end_offset)
+        return insert_after(opening, text) unless interior.include?("\n")
+
+        indentation = @source_file.indentation_at(closing.start_offset)
+        offset = @source_file.line_start(closing.start_offset)
+        insert_before(offset...offset, "#{indentation}#{@source_file.indent_unit}#{text}#{@source_file.newline}")
+      end
+    end
+  end
+end

data/lib/astel/rewriter/structured/comments.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Astel
+  class Rewriter
+    module Structured
+      def leading_comments(node)
+        attach_comments
+        node.location.leading_comments
+      end
+
+      def trailing_comment(node)
+        attach_comments
+        node.location.trailing_comments.first
+      end
+
+      def remove_with_comments(node)
+        comments = leading_comments(node)
+        trailing = trailing_comment(node)
+        start_offset = comments.empty? ? node.location.start_offset : comments.first.location.start_offset
+        end_offset = [node_end_offset(node), trailing&.location&.end_offset].compact.max
+        remove_lines_if_isolated(start_offset: start_offset, end_offset: end_offset)
+      end
+
+      private
+
+      def attach_comments
+        @source_file.attach_comments!
+      end
+    end
+  end
+end