ffast 0.2.2 → 0.2.3

data/lib/fast/source.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Fast
+  module Source
+    class Buffer
+      attr_accessor :source
+      attr_reader :name
+
+      def initialize(name, source: nil)
+        @name = name
+        @source = source
+      end
+
+      def source_range(begin_pos = 0, end_pos = source.to_s.length)
+        Fast::Source.range(self, begin_pos, end_pos)
+      end
+    end
+
+    class Range
+      attr_reader :begin_pos, :end_pos, :source_buffer
+
+      def initialize(source_buffer, begin_pos, end_pos)
+        @source_buffer = source_buffer
+        @begin_pos = begin_pos
+        @end_pos = end_pos
+      end
+
+      def begin
+        self.class.new(source_buffer, begin_pos, begin_pos)
+      end
+
+      def end
+        self.class.new(source_buffer, end_pos, end_pos)
+      end
+
+      def source
+        source_buffer.source.to_s[begin_pos...end_pos]
+      end
+
+      def line
+        first_line
+      end
+
+      def first_line
+        source_buffer.source.to_s[0...begin_pos].count("\n") + 1
+      end
+
+      def last_line
+        source_buffer.source.to_s[0...end_pos].count("\n") + 1
+      end
+
+      def column
+        last_newline = source_buffer.source.to_s.rindex("\n", begin_pos - 1)
+        begin_pos - (last_newline ? last_newline + 1 : 0)
+      end
+
+      def to_range
+        begin_pos...end_pos
+      end
+
+      def join(other)
+        self.class.new(source_buffer, [begin_pos, other.begin_pos].min, [end_pos, other.end_pos].max)
+      end
+
+      def adjust(begin_pos: 0, end_pos: 0)
+        self.class.new(source_buffer, self.begin_pos + begin_pos, self.end_pos + end_pos)
+      end
+    end
+
+    class Map
+      attr_accessor :expression, :node
+
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def begin
+        expression.begin_pos
+      end
+
+      def end
+        expression.end_pos
+      end
+
+      def with_expression(new_expression)
+        duplicate_with(expression: new_expression)
+      end
+
+      def with_operator(operator)
+        duplicate_with(operator: operator)
+      end
+
+      private
+
+      def duplicate_with(overrides = {})
+        copy = dup
+        overrides.each { |name, value| copy.instance_variable_set(:"@#{name}", value) }
+        copy
+      end
+    end
+
+    module_function
+
+    def buffer(name, source: nil, buffer_class: Fast::Source::Buffer)
+      buffer_class.new(name, source: source)
+    end
+
+    def range(buffer, start_pos, end_pos)
+      Fast::Source::Range.new(buffer, start_pos, end_pos)
+    end
+
+    def map(expression)
+      Fast::Source::Map.new(expression)
+    end
+  end
+end

data/lib/fast/source_rewriter.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative 'source'
+
+module Fast
+  class SourceRewriter
+    Edit = Struct.new(:kind, :begin_pos, :end_pos, :content, :order, keyword_init: true)
+    ClobberingError = Class.new(StandardError)
+
+    attr_reader :source_buffer
+
+    def initialize(source_buffer)
+      @source_buffer = source_buffer
+      @edits = []
+      @order = 0
+    end
+
+    def replace(range, content)
+      add_edit(:replace, range, content.to_s)
+      self
+    end
+
+    def remove(range)
+      replace(range, '')
+    end
+
+    def wrap(range, before, after)
+      insert_before(range, before) unless before.nil?
+      insert_after(range, after) unless after.nil?
+      self
+    end
+
+    def insert_before(range, content)
+      add_edit(:insert_before, range.begin, content.to_s)
+      self
+    end
+
+    def insert_after(range, content)
+      add_edit(:insert_after, range.end, content.to_s)
+      self
+    end
+
+    def process
+      source = source_buffer.source.to_s
+      normalized_replacements = normalize_replacements
+      return source if normalized_replacements.empty? && insertions.empty?
+
+      before_insertions = build_insertions(:insert_before)
+      after_insertions = build_insertions(:insert_after)
+
+      result = +''
+      cursor = 0
+
+      normalized_replacements.each do |replacement|
+        result << emit_unreplaced_segment(source, cursor, replacement.begin_pos, before_insertions, after_insertions)
+        result << before_insertions.fetch(replacement.begin_pos, '')
+        result << replacement.content
+        result << after_insertions.fetch(replacement.end_pos, '')
+        cursor = replacement.end_pos
+      end
+
+      result << emit_unreplaced_segment(source, cursor, source.length, before_insertions, after_insertions)
+      result
+    end
+
+    private
+
+    attr_reader :edits
+
+    def add_edit(kind, range, content)
+      edits << Edit.new(
+        kind: kind,
+        begin_pos: range.begin_pos,
+        end_pos: range.end_pos,
+        content: content,
+        order: next_order
+      )
+    end
+
+    def next_order
+      @order += 1
+    end
+
+    def insertions
+      edits.select { |edit| insertion?(edit) }
+    end
+
+    def replacements
+      edits.reject { |edit| insertion?(edit) }
+    end
+
+    def insertion?(edit)
+      edit.kind == :insert_before || edit.kind == :insert_after
+    end
+
+    def normalize_replacements
+      replacements
+        .sort_by { |edit| [edit.begin_pos, edit.end_pos, edit.order] }
+        .each_with_object([]) do |edit, normalized|
+          previous = normalized.last
+          if previous && overlaps?(previous, edit)
+            if deletion?(previous) && deletion?(edit)
+              previous.end_pos = [previous.end_pos, edit.end_pos].max
+            elsif same_range?(previous, edit)
+              previous.content = edit.content
+              previous.order = edit.order
+            else
+              raise ClobberingError, "Overlapping rewrite on #{edit.begin_pos}...#{edit.end_pos}"
+            end
+          else
+            normalized << edit.dup
+          end
+        end
+    end
+
+    def overlaps?(left, right)
+      left.begin_pos < right.end_pos && right.begin_pos < left.end_pos
+    end
+
+    def same_range?(left, right)
+      left.begin_pos == right.begin_pos && left.end_pos == right.end_pos
+    end
+
+    def deletion?(edit)
+      edit.content.empty?
+    end
+
+    def build_insertions(kind)
+      edits
+        .select { |edit| edit.kind == kind }
+        .group_by(&:begin_pos)
+        .transform_values do |position_edits|
+          position_edits
+            .sort_by(&:order)
+            .map(&:content)
+            .join
+        end
+    end
+
+    def emit_unreplaced_segment(source, from, to, before_insertions, after_insertions)
+      segment = +''
+      cursor = from
+
+      while cursor < to
+        segment << before_insertions.fetch(cursor, '')
+        segment << source[cursor]
+        cursor += 1
+        segment << after_insertions.fetch(cursor, '')
+      end
+      segment
+    end
+  end
+end

data/lib/fast/sql/rewriter.rb

@@ -4,12 +4,12 @@ module Fast
       # @see Fast::SQLRewriter
       # @return string with the content updated in case the pattern matches.
       def replace(pattern, ast, &replacement)
-        sql_rewriter_for(pattern, ast, &replacement).rewrite!
+        rewriter_for(pattern, ast, &replacement).rewrite!
       end
 
       # @return [Fast::SQL::Rewriter]
       # @see Fast::Rewriter
-      def sql_rewriter_for(pattern, ast, &replacement)
+      def rewriter_for(pattern, ast, &replacement)
         rewriter = Rewriter.new
         rewriter.ast = ast
         rewriter.search = pattern
@@ -41,24 +41,53 @@ module Fast
     # @see Fast::Rewriter
     class Rewriter < Fast::Rewriter
 
+      def rewrite!
+        replace_on(*types)
+        case ast
+        when Array
+          rewrite(buffer, ast.first)
+        else
+          rewrite(buffer, ast)
+        end
+      end
+
+      def source
+        super ||
+          begin
+            case ast
+            when Array
+              ast.first
+            else
+              ast
+            end.location.expression.source_buffer.source
+          end
+      end
       # @return [Array<Symbol>] with all types that matches
       def types
-        ast.type
+        case ast
+        when Array
+          ast.map(&:type)
+        when NilClass
+          []
+        else
+          ast.type
+        end
       end
 
       # Generate methods for all affected types.
-      # Note the strategy is different from parent class, it if matches the root node, it executes otherwise it search pattern on
+      # Note the strategy is different from parent class,
+      # it will not stop on first match, but will execute the replacement on
       # all matching elements.
       # @see Fast.replace
       def replace_on(*types)
         types.map do |type|
           self.instance_exec do
-            self.class.define_method :"on_#{ast.type}" do |node|
+            self.class.define_method :"on_#{type}" do |node|
               # SQL nodes are not being automatically invoked by the rewriter,
               # so we need to match the root node and invoke on matching inner elements.
-              node.search(search).each_with_index do |node, i|
+              Fast.search(search, ast).each_with_index do |node, i|
                 @match_index += 1
-                execute_replacement(node, nil)
+                execute_replacement(node, i)
               end
             end
           end

data/lib/fast/sql.rb

@@ -1,4 +1,5 @@
 require 'pg_query'
+require_relative '../fast/source'
 require_relative 'sql/rewriter'
 
 module Fast
@@ -42,10 +43,10 @@ module Fast
   #               s(:val,
   #                 s(:string,
   #                   s(:str, "hello AST"))))))))
-  # `s` represents a Fast::Node which is a subclass of Parser::AST::Node and
-  # has additional methods to access the tokens and location of the node.
+  # `s` represents a Fast::Node with additional methods to access the tokens
+  # and location of the node.
   # ast.search(:string).first.location.expression
-  #  => #<Parser::Source::Range (sql) 7...18>
+  #  => #<Fast::Source::Range (sql) 7...18>
   def parse_sql(statement, buffer_name: "(sql)")
     SQL.parse(statement, buffer_name: buffer_name)
   end
@@ -53,26 +54,26 @@ module Fast
   # This module contains methods to parse SQL statements and rewrite them.
   # It uses PGQuery to parse the SQL statements.
   # It uses Parser to rewrite the SQL statements.
-  # It uses Parser::Source::Map to map the AST nodes to the SQL tokens.
+  # It uses Fast::Source::Map to map the AST nodes to the SQL tokens.
   #
   # @example
   #  Fast::SQL.parse("select 1")
   #  => s(:select_stmt, s(:target_list, ...
   # @see Fast::SQL::Node
   module SQL
-    # The SQL source buffer is a subclass of Parser::Source::Buffer
+    # The SQL source buffer is a subclass of Fast::Source::Buffer
     # which contains the tokens of the SQL statement.
     # When you call `ast.location.expression` it will return a range
     # which is mapped to the tokens.
     # @example
     # ast = Fast::SQL.parse("select 1")
-    # ast.location.expression # => #<Parser::Source::Range (sql) 0...9>
+    # ast.location.expression # => #<Fast::Source::Range (sql) 0...9>
     # ast.location.expression.source_buffer.tokens
     # => [
     #   <PgQuery::ScanToken: start: 0, end: 6, token: :SELECT, keyword_kind: :RESERVED_KEYWORD>,
     #   <PgQuery::ScanToken: start: 7, end: 8, token: :ICONST, keyword_kind: :NO_KEYWORD>]
     # @see Fast::SQL::Node
-    class SourceBuffer < Parser::Source::Buffer
+    class SourceBuffer < Fast::Source::Buffer
       def tokens
         @tokens ||= PgQuery.scan(source).first.tokens
       end
@@ -111,15 +112,13 @@ module Fast
       return [] if statement.nil?
       source_buffer = SQL::SourceBuffer.new(buffer_name, source: statement)
       tree = PgQuery.parse(statement).tree
+      first, *, last = source_buffer.tokens
       stmts = tree.stmts.map do |stmt|
-        v = clean_structure(stmt.stmt.to_h)
-        inner_stmt = statement[stmt.stmt_location, stmt.stmt_len]
-        first, *, last = source_buffer.tokens
         from = stmt.stmt_location
-        to = from.zero? ? last.end : from + stmt.stmt_len
-        expression = Parser::Source::Range.new(source_buffer, from, to)
-        source_map = Parser::Source::Map.new(expression)
-        sql_tree_to_ast(v, source_buffer: source_buffer, source_map: source_map)
+        to = stmt.stmt_len.zero? ? last.end : from + stmt.stmt_len
+        expression = Fast::Source.range(source_buffer, from, to)
+        source_map = Fast::Source.map(expression)
+        sql_tree_to_ast(clean_structure(stmt.stmt.to_h), source_buffer: source_buffer, source_map: source_map)
       end.flatten
       stmts.one? ? stmts.first : stmts
     end
@@ -150,8 +149,8 @@ module Fast
       when Hash
         if (start = obj.delete(:location))
           if (token = source_buffer.tokens.find{|e|e.start == start})
-            expression = Parser::Source::Range.new(source_buffer, token.start, token.end)
-            source_map = Parser::Source::Map.new(expression)
+            expression = Fast::Source.range(source_buffer, token.start, token.end)
+            source_map = Fast::Source.map(expression)
           end
         end
         obj.map do |key, value|
@@ -164,4 +163,3 @@ module Fast
     end
   end
 end
-