astel 0.2.0 → 0.3.0

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

@@ -1,192 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../astel'
+require_relative 'rewriter/structured'
 
 module Astel
-  module Refactor
-    def find_keyword_argument(call_node, name)
-      keyword_hashes(call_node).each do |keyword_hash|
-        match = keyword_hash.elements.find { |element| keyword_name(element) == name.to_sym }
-        return match if match
-      end
-      nil
-    end
-
-    def remove_keyword_argument(call_node, name)
-      argument = find_keyword_argument(call_node, name)
-      return self unless argument
-
-      keyword_hash = keyword_hashes(call_node).find { |hash| hash.elements.include?(argument) }
-      if keyword_hash.elements.one?
-        if call_node.arguments.arguments.one? && !call_node.opening_loc
-          return remove(call_node.message_loc.end_offset...keyword_hash.location.end_offset)
-        end
-        remove_list_element(call_node.arguments, keyword_hash)
-      else
-        remove_list_element(keyword_hash, argument)
-      end
-    end
-
-    def replace_keyword_key(assoc_node, name)
-      replacement = assoc_node.operator_loc ? ":#{name}" : "#{name}:"
-      replace(assoc_node.key.location, replacement)
-    end
-
-    def replace_keyword_value(assoc_node, replacement)
-      replace(assoc_node.value.location, replacement)
-    end
-
-    def insert_keyword_argument(call_node, text, position: :last)
-      raise ArgumentError, 'position must be :first or :last' unless %i[first last].include?(position)
-
-      arguments = call_node.arguments
-      unless arguments
-        location = call_node.opening_loc || call_node.message_loc
-        if call_node.opening_loc && call_node.closing_loc
-          return insert_into_empty_delimited(call_node, text)
-        end
-        return insert_after(location, call_node.opening_loc ? text : " #{text}")
-      end
-
-      keyword_hash = keyword_hashes(call_node).first
-      if keyword_hash
-        index = position == :first ? 0 : keyword_hash.elements.length
-        return insert_list_element(keyword_hash, index, text)
-      end
-
-      index = arguments.arguments.length
-      insert_list_element(arguments, index, text)
-    end
-
-    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_nodes.map do |element|
-        elements.index { |candidate| candidate.equal?(element) } ||
-          raise(ArgumentError, 'element does not belong to collection')
-      end.uniq.sort
-      return self if indexes.empty?
-
-      trailing_end = trailing_comma_end(elements.last)
-      replacements = deletion_ranges(elements, indexes, trailing_end)
-      start_offset = elements.first.location.start_offset
-      end_offset = trailing_end
-      content = @source_file.source.byteslice(start_offset, end_offset - start_offset).dup
-      replacements.reverse_each do |from, to, replacement|
-        content[(from - start_offset)...(to - start_offset)] = replacement
-      end
-      replace(start_offset...end_offset, content)
-    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]
-        separator = multiline_collection?(collection_node) ? ",#{@source_file.newline}#{indentation_of(target)}" : ', '
-        return insert_before(target.location, "#{text}#{separator}")
-      end
-
-      last = elements.last
-      separator = multiline_collection?(collection_node) ? ",#{@source_file.newline}#{indentation_of(last)}" : ', '
-      insert_after(last.location, "#{separator}#{text}")
-    end
-
-    private
-
-    def keyword_hashes(call_node)
-      call_node.arguments&.arguments&.grep(Prism::KeywordHashNode) || []
-    end
-
-    def keyword_name(assoc_node)
-      key = assoc_node.key
-      key.unescaped.to_sym if key.is_a?(Prism::SymbolNode)
-    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] }
-      groups = indexes.slice_when { |left, right| right != left + 1 }.to_a
-      groups.map do |group|
-        first = group.first
-        last = group.last
-        following = ((last + 1)...elements.length).find { |index| !removed[index] }
-        preceding = (first - 1).downto(0).find { |index| !removed[index] }
-
-        if following
-          [elements[first].location.start_offset, elements[following].location.start_offset, '']
-        elsif 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 = if has_trailing_comma
-                          between.include?('#') ? between.rstrip : ','
-                        elsif between.include?('#')
-                          between.sub(',', '').rstrip
-                        else
-                          ''
-                        end
-          [from, to, replacement]
-        else
-          [elements.first.location.start_offset, trailing_end, '']
-        end
-      end
-    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 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)
-      replacement = "#{@source_file.newline}#{indentation}#{@source_file.indent_unit}#{text}" \
-                    "#{@source_file.newline}#{indentation}"
-      replace(opening.end_offset...closing.start_offset, replacement)
-    end
-  end
+  Refactor = Rewriter.const_get(:Structured, false)
 end
-
-require_relative 'refactor/formatting'
-require_relative 'refactor/comments'
-
-Astel::Rewriter.include(Astel::Refactor)

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