astel 0.2.0 → 0.3.0

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

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative 'source_indenter'
+
+module Astel
+  class Rewriter
+    module Structured
+      def indentation_of(node)
+        @source_file.indentation_at(node.location.start_offset)
+      end
+
+      def indent(text, level: 1)
+        prefix = @source_file.indent_unit * level
+        text.lines(chomp: false).map { |line| line.strip.empty? ? line : "#{prefix}#{line}" }.join
+      end
+
+      def dedent(text)
+        width = dedentation_width(text)
+        text.lines(chomp: false).map { |line| line.strip.empty? ? line : line.byteslice(width..) }.join
+      end
+
+      def reindent(text, to:)
+        prefix = indentation_of(to)
+        dedent(text).lines(chomp: false).map { |line| line.strip.empty? ? line : "#{prefix}#{line}" }.join
+      end
+
+      def insert_into_body(node, source_text, position: :end)
+        statements = body_statements(node)
+        target, after, section_break = body_insertion_target(node, statements, position)
+        content = format_body_source(source_text, body_child_indentation(node, statements))
+        return insert_body_source_after(node, target, content) if after
+
+        insert_body_source_before(node, target, content, section_break: section_break)
+      end
+
+      def remove_line(node)
+        remove_lines_if_isolated(
+          start_offset: node.location.start_offset,
+          end_offset: node_end_offset(node)
+        )
+      end
+
+      def insert_line_before(node, text)
+        line_start = @source_file.line_start(node.location.start_offset)
+        content = format_body_source(text, indentation_of(node))
+        insert_before(line_start...line_start, "#{content}#{@source_file.newline}")
+      end
+
+      def insert_line_after(node, text)
+        line = @source_file.line_location_with_newline(node_end_offset(node) - 1)
+        content = format_body_source(text, indentation_of(node))
+        prefix = line_terminated?(line) ? '' : @source_file.newline
+        insert_after(line, "#{prefix}#{content}#{@source_file.newline}")
+      end
+
+      def comment_out(node)
+        first = @source_file.line_start(node.location.start_offset)
+        last = @source_file.line_end([node_end_offset(node) - 1, node.location.start_offset].max)
+        text = @source_file.source.byteslice(first, last - first)
+        commented = text.lines(chomp: false).map do |line|
+          indentation = line[/\A[ \t]*/]
+          "#{indentation}# #{line.delete_prefix(indentation)}"
+        end.join
+        replace(first...last, commented)
+      end
+
+      private
+
+      def dedentation_width(text)
+        text.lines.filter_map do |line|
+          line[/\A[ \t]*/].bytesize unless line.strip.empty?
+        end.min || 0
+      end
+
+      def remove_lines_if_isolated(start_offset:, end_offset:)
+        first = @source_file.line_location(start_offset)
+        last_offset = [end_offset - 1, start_offset].max
+        last = @source_file.line_location(last_offset)
+        before = @source_file.source.byteslice(first.start_offset, start_offset - first.start_offset)
+        after = @source_file.source.byteslice(end_offset...last.end_offset) || ''
+        return remove(start_offset...end_offset) unless before.strip.empty? && after.strip.empty?
+
+        ending = @source_file.line_location_with_newline(last_offset).end_offset
+        remove(first.start_offset...ending)
+      end
+
+      def body_child_indentation(node, statements)
+        first_statement = statements&.body&.first
+        if first_statement &&
+           @source_file.line_at(first_statement.location.start_offset) != @source_file.line_at(node.location.start_offset)
+          return indentation_of(first_statement)
+        end
+
+        "#{indentation_of(node)}#{@source_file.indent_unit}"
+      end
+
+      def insert_body_source_after(node, target, content)
+        if inline_body_end?(node, target)
+          return insert_after(target.location, "#{@source_file.newline}#{content}")
+        end
+
+        line = @source_file.line_location_with_newline(node_end_offset(target) - 1)
+        prefix = line_terminated?(line) ? '' : @source_file.newline
+        insert_after(line, "#{prefix}#{content}#{@source_file.newline}")
+      end
+
+      def insert_body_source_before(node, target, content, section_break:)
+        return insert_inline_body_source(target, content) if inline_body_start?(node, target)
+
+        offset = if target
+                   @source_file.line_start(target.location.start_offset)
+                 else
+                   body_insertion_offset(node)
+                 end
+        prefix = needs_leading_newline?(offset) ? @source_file.newline : ''
+        suffix = section_break ? @source_file.newline * 2 : @source_file.newline
+        insert_before(offset...offset, "#{prefix}#{content}#{suffix}")
+      end
+
+      def body_statements(node)
+        body = node.respond_to?(:body) ? node.body : nil
+        return body if body.is_a?(Prism::StatementsNode)
+        return body.statements if body.is_a?(Prism::BeginNode)
+      end
+
+      def body_closing_location(node)
+        return node.end_keyword_loc if node.respond_to?(:end_keyword_loc) && node.end_keyword_loc
+        return node.closing_loc if node.respond_to?(:closing_loc) && node.closing_loc
+
+        raise ArgumentError, 'node does not have a delimited body'
+      end
+
+      def body_insertion_offset(node)
+        location = normal_body_boundary(node)
+        line_start = @source_file.line_start(location.start_offset)
+        prefix = @source_file.source.byteslice(line_start, location.start_offset - line_start)
+        prefix.strip.empty? ? line_start : location.start_offset
+      end
+
+      def normal_body_boundary(node)
+        body = node.respond_to?(:body) ? node.body : nil
+        if body.is_a?(Prism::BeginNode)
+          return body.rescue_clause.keyword_loc if body.rescue_clause
+          return body.else_clause.else_keyword_loc if body.else_clause
+          return body.ensure_clause.ensure_keyword_loc if body.ensure_clause
+        end
+        body_closing_location(node)
+      end
+
+      def body_insertion_target(node, statements, position)
+        body = statements&.body || []
+        case position
+        when :beginning then return [body.first, false, false]
+        when :end then return [nil, false, false]
+        when :before_private
+          marker = body.find { |child| visibility_marker?(child) }
+          return [marker, false, !marker.nil?]
+        when Hash
+          return [position.fetch(:after), true, false] if position.key?(:after)
+          return [position.fetch(:before), false, false] if position.key?(:before)
+        end
+        raise ArgumentError, 'unsupported body insertion position'
+      end
+
+      def visibility_marker?(node)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? && node.arguments.nil? &&
+          %i[private protected].include?(node.name)
+      end
+
+      def format_body_source(text, indentation)
+        SourceIndenter.new(text.to_s, indentation: indentation,
+                           newline: @source_file.newline).call
+      end
+
+      def inline_body_start?(node, target)
+        target && @source_file.line_at(target.location.start_offset) ==
+          @source_file.line_at(node.location.start_offset)
+      end
+
+      def inline_body_end?(node, target)
+        @source_file.line_at(target.location.end_offset) ==
+          @source_file.line_at(body_closing_location(node).start_offset)
+      end
+
+      def insert_inline_body_source(target, content)
+        indentation = content[/\A[ \t]*/]
+        replacement = "#{content.delete_prefix(indentation)}#{@source_file.newline}#{indentation}"
+        insert_before(target.location, replacement)
+      end
+
+      def needs_leading_newline?(offset)
+        offset.positive? && ![10, 13].include?(@source_file.source.getbyte(offset - 1))
+      end
+
+      def line_terminated?(location)
+        location.end_offset.positive? && @source_file.source.getbyte(location.end_offset - 1) == 10
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Astel
+  class Rewriter
+    module Structured
+      class SourceIndenter
+        def initialize(source, indentation:, newline:)
+          @source = source
+          @indentation = indentation
+          @newline = newline
+        end
+
+        def call
+          protected_ranges = protected_source_ranges
+          width = dedentation_width(protected_ranges)
+          formatted = String.new(encoding: @source.encoding)
+          offset = 0
+
+          @source.lines(chomp: false).each do |line|
+            body, line_ending = split_line_ending(line)
+            line_ending = @newline if line_ending && !protected_offset?(offset + body.bytesize, protected_ranges)
+            unless body.strip.empty? || protected_offset?(offset, protected_ranges)
+              leading_width = body[/\A[ \t]*/].bytesize
+              body = "#{@indentation}#{body.byteslice([width, leading_width].min..)}"
+            end
+            formatted << body << line_ending.to_s
+            offset += line.bytesize
+          end
+
+          remove_final_line_ending(formatted)
+        end
+
+        private
+
+        def protected_source_ranges
+          parsed, prefix_length = parse_source
+          raise ArgumentError, 'source text must be valid Ruby' unless parsed.errors.empty?
+
+          queue = [parsed.value]
+          queue.each_with_object([]) do |node, ranges|
+            queue.concat(node.compact_child_nodes)
+            content = node.respond_to?(:content_loc) && node.content_loc
+            ranges << (content.start_offset...content.end_offset) if content
+            ranges << (node.closing_loc.start_offset...node.closing_loc.end_offset) if
+              node.respond_to?(:heredoc?) && node.heredoc? && node.closing_loc
+          end.map { |range| (range.begin - prefix_length)...(range.end - prefix_length) }
+        end
+
+        def parse_source
+          return [Prism.parse(@source), 0] if @source.encoding == Encoding::UTF_8 || @source.ascii_only?
+
+          prefix = "# encoding: #{@source.encoding.name}\n".encode(@source.encoding)
+          [Prism.parse(prefix + @source), prefix.bytesize]
+        end
+
+        def dedentation_width(protected_ranges)
+          offset = 0
+          widths = @source.lines(chomp: false).filter_map do |line|
+            body, = split_line_ending(line)
+            protected = protected_offset?(offset, protected_ranges)
+            offset += line.bytesize
+            body[/\A[ \t]*/].bytesize unless body.strip.empty? || protected
+          end
+          widths.min || 0
+        end
+
+        def split_line_ending(line)
+          return [line.byteslice(0, line.bytesize - 2), "\r\n"] if line.end_with?("\r\n")
+          return [line.byteslice(0, line.bytesize - 1), "\n"] if line.end_with?("\n")
+
+          [line, nil]
+        end
+
+        def protected_offset?(offset, ranges)
+          ranges.any? { |range| offset.between?(range.begin, range.end) }
+        end
+
+        def remove_final_line_ending(text)
+          return text.byteslice(0, text.bytesize - 2) if text.end_with?("\r\n")
+          return text.byteslice(0, text.bytesize - 1) if text.end_with?("\n")
+
+          text
+        end
+      end
+      private_constant :SourceIndenter
+    end
+  end
+end

data/lib/astel/rewriter/structured.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative '../../astel'
+
+module Astel
+  class Rewriter
+    module Structured
+      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) }
+        return remove_sole_keyword_argument(call_node, keyword_hash) if keyword_hash.elements.one?
+
+        remove_list_element(keyword_hash, argument)
+      end
+
+      def replace_keyword_key(assoc_node, name)
+        if implicit_keyword_value?(assoc_node)
+          return replace(assoc_node.location, "#{name}: #{assoc_node.value.value.name}")
+        end
+
+        replacement = assoc_node.operator_loc ? ":#{name}" : "#{name}:"
+        replace(assoc_node.key.location, replacement)
+      end
+
+      def replace_keyword_value(assoc_node, replacement)
+        if implicit_keyword_value?(assoc_node)
+          return replace(assoc_node.location, "#{@source_file.slice(assoc_node.key.location)} #{replacement}")
+        end
+
+        replace_expression(assoc_node.value, 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
+        return insert_first_keyword_argument(call_node, text) unless arguments
+
+        keyword_hash = keyword_hashes(call_node).first
+        return insert_into_keyword_hash(keyword_hash, text, position) if keyword_hash
+
+        index = arguments.arguments.length
+        insert_list_element(arguments, index, text)
+      end
+
+      private
+
+      def replace_expression(node, replacement)
+        ranges = heredoc_ranges(node)
+        return replace(node.location, replacement) if ranges.empty?
+
+        transaction(raise_on_conflict: true) do |rewriter|
+          rewriter.replace(node.location, replacement)
+          ranges.each { |range| rewriter.remove(range) }
+        end
+        self
+      end
+
+      def remove_sole_keyword_argument(call_node, keyword_hash)
+        if call_node.arguments.arguments.one? && !call_node.opening_loc
+          preserved = remove_commented_keyword_before_block(call_node, keyword_hash)
+          return preserved if preserved
+
+          ending = call_node.block&.location&.start_offset || keyword_hash.location.end_offset
+          replacement = call_node.block ? ' ' : ''
+          return replace(call_node.message_loc.end_offset...ending, replacement)
+        end
+
+        remove_list_element(call_node.arguments, keyword_hash)
+      end
+
+      def remove_commented_keyword_before_block(call_node, keyword_hash)
+        block = call_node.block
+        return unless block.is_a?(Prism::BlockArgumentNode)
+
+        source = @source_file.source
+        separator = source.byteslice(keyword_hash.location.end_offset,
+                                     block.location.start_offset - keyword_hash.location.end_offset)
+        return unless separator.include?('#')
+
+        separator = separator.sub(/\A[ \t]*,[ \t]*/, '')
+        replacement = "(#{separator}#{@source_file.slice(block.location)})"
+        replace(call_node.message_loc.end_offset...block.location.end_offset, replacement)
+      end
+
+      def insert_first_keyword_argument(call_node, text)
+        return insert_keyword_before_block(call_node, text) if call_node.block.is_a?(Prism::BlockArgumentNode)
+        return insert_into_empty_delimited(call_node, text) if call_node.opening_loc && call_node.closing_loc
+        return insert_after(call_node.message_loc, "(#{text})") if call_node.block
+
+        location = call_node.opening_loc || call_node.message_loc
+        insert_after(location, call_node.opening_loc ? text : " #{text}")
+      end
+
+      def insert_into_keyword_hash(keyword_hash, text, position)
+        index = position == :first ? 0 : keyword_hash.elements.length
+        insert_list_element(keyword_hash, index, text)
+      end
+
+      def keyword_hashes(call_node)
+        call_node.arguments&.arguments&.grep(Prism::KeywordHashNode) || []
+      end
+
+      def keyword_name(assoc_node)
+        return unless assoc_node.is_a?(Prism::AssocNode)
+
+        key = assoc_node.key
+        key.unescaped.to_sym if key.is_a?(Prism::SymbolNode)
+      end
+
+      def implicit_keyword_value?(assoc_node)
+        assoc_node.value.is_a?(Prism::ImplicitNode)
+      end
+
+      def insert_keyword_before_block(call_node, text)
+        block = call_node.block
+        separator = if @source_file.line_at(block.location.start_offset) ==
+                       @source_file.line_at((call_node.opening_loc || call_node.message_loc).end_offset)
+                      ', '
+                    else
+                      ",#{@source_file.newline}#{indentation_of(block)}"
+                    end
+        insert_before(block.location, "#{text}#{separator}")
+      end
+
+      def heredoc_ranges(node)
+        queue = [node]
+        ranges = []
+        until queue.empty?
+          current = queue.shift
+          queue.concat(current.compact_child_nodes)
+          next unless current.respond_to?(:heredoc?) && current.heredoc? && current.closing_loc
+
+          content = current.content_loc if current.respond_to?(:content_loc)
+          start_offset = content&.start_offset || current.compact_child_nodes.map(&:location).map(&:start_offset).min
+          ranges << (start_offset...current.closing_loc.end_offset) if start_offset
+        end
+        ranges
+      end
+
+      def node_end_offset(node)
+        [node.location.end_offset, *heredoc_ranges(node).map(&:end)].max
+      end
+    end
+  end
+end
+
+require_relative 'structured/collections'
+require_relative 'structured/formatting'
+require_relative 'structured/comments'
+
+Astel::Rewriter.include(Astel::Rewriter::Structured)
+Astel::Rewriter.private_constant(:Structured)