ffast 0.2.0 → 0.2.3

data/lib/fast/shortcut.rb

@@ -7,14 +7,18 @@ module Fast
     # 1. Current directory that the command is being runned
     # 2. Home folder
     # 3. Using the `FAST_FILE_DIR` variable to set an extra folder
-    LOOKUP_FAST_FILES_DIRECTORIES = [Dir.pwd, ENV['HOME'], ENV['FAST_FILE_DIR']].freeze
+    LOOKUP_FAST_FILES_DIRECTORIES = [
+      Dir.pwd,
+      ENV['HOME'],
+      ENV['FAST_FILE_DIR'],
+      File.join(File.dirname(__FILE__), '..', '..')
+    ].reverse.compact.map(&File.method(:expand_path)).uniq.freeze
 
     # Store predefined searches with default paths through shortcuts.
     # define your Fastfile in you root folder or
     # @example Shortcut for finding validations in rails models
     #   Fast.shortcut(:validations, "(send nil {validate validates})", "app/models")
     def shortcut(identifier, *args, &block)
-      puts "identifier #{identifier.inspect} will be override" if shortcuts.key?(identifier)
       shortcuts[identifier] = Shortcut.new(*args, &block)
     end
 
@@ -29,12 +33,25 @@ module Fast
     def fast_files
       @fast_files ||= LOOKUP_FAST_FILES_DIRECTORIES.compact
         .map { |dir| File.join(dir, 'Fastfile') }
-        .select(&File.method(:exists?))
+        .select(&File.method(:exist?))
     end
 
     # Loads `Fastfiles` from {.fast_files} list
     def load_fast_files!
-      fast_files.each(&method(:load))
+      @loaded_fast_files ||= []
+      fast_files.each do |file|
+        next if @loaded_fast_files.include?(file)
+
+        load file
+        @loaded_fast_files << file
+      end
+    end
+
+    def render_markdown_for_terminal(line)
+      require 'tty-markdown'
+      TTY::Markdown.parse(line)
+    rescue LoadError
+      line
     end
   end
 
@@ -60,7 +77,7 @@ module Fast
     def merge_args(extra_args)
       all_args = (@args + extra_args).uniq
       options = all_args.select { |arg| arg.start_with? '-' }
-      files = extra_args.select(&File.method(:exists?))
+      files = extra_args.select(&File.method(:exist?))
       command = (@args - options - files).first
 
       [command, *options, *files]
@@ -73,7 +90,7 @@ module Fast
     # Use ARGV to catch regular arguments from command line if the block is
     # given.
     #
-    # @return [Hash<String, Array<Astrolabe::Node>] with file => search results.
+    # @return [Hash<String, Array<Fast::Node>>] with file => search results.
     def run
       Fast.instance_exec(&@block) if single_run_with_block?
     end

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

@@ -0,0 +1,98 @@
+module Fast
+  module SQL
+    class << self
+      # @see Fast::SQLRewriter
+      # @return string with the content updated in case the pattern matches.
+      def replace(pattern, ast, &replacement)
+        rewriter_for(pattern, ast, &replacement).rewrite!
+      end
+
+      # @return [Fast::SQL::Rewriter]
+      # @see Fast::Rewriter
+      def rewriter_for(pattern, ast, &replacement)
+        rewriter = Rewriter.new
+        rewriter.ast = ast
+        rewriter.search = pattern
+        rewriter.replacement = replacement
+        rewriter
+      end
+
+      # @return Fast::SQL::Node with the parsed content
+      def parse_file(file)
+        parse(IO.read(file), buffer_name: file)
+      end
+
+      # Replace a SQL file with the given pattern.
+      # Use a replacement code block to change the content.
+      # @return nil in case does not update the file
+      # @return true in case the file is updated
+      # @see Fast::SQL::Rewriter
+      def replace_file(pattern, file, &replacement)
+        original = IO.read(file)
+        ast = parse_file(file)
+        content = replace(pattern, ast, &replacement)
+        if content != original
+          File.open(file, 'w+') { |f| f.print content }
+        end
+      end
+    end
+
+    # Extends fast rewriter to support SQL
+    # @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
+        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 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_#{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.
+              Fast.search(search, ast).each_with_index do |node, i|
+                @match_index += 1
+                execute_replacement(node, i)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast/sql.rb

@@ -0,0 +1,165 @@
+require 'pg_query'
+require_relative '../fast/source'
+require_relative 'sql/rewriter'
+
+module Fast
+
+  module_function
+
+  # Shortcut to parse a sql file
+  # @example Fast.parse_sql_file('spec/fixtures/sql/select.sql')
+  # @return [Fast::Node] the AST representation of the sql statements from a file
+  def parse_sql_file(file)
+    SQL.parse_file(file)
+  end
+
+  # @return [Fast::SQLRewriter] which can be used to rewrite the SQL
+  # @see Fast::SQLRewriter
+  def sql_rewriter_for(pattern, ast, &replacement)
+    SQL.rewriter_for(pattern, ast, &replacement)
+  end
+
+  # @return string with the sql content updated in case the pattern matches.
+  # @see Fast::SQLRewriter
+  # @example
+  # Fast.replace_sql('ival', Fast.parse_sql('select 1'), &->(node){ replace(node.location.expression, '2') }) # => "select 2"
+  def replace_sql(pattern, ast, &replacement)
+    SQL.replace(pattern, ast, &replacement)
+  end
+
+  # @return string with the sql content updated in case the pattern matches.
+  def replace_sql_file(pattern, file, &replacement)
+    SQL.replace_file(pattern, file, &replacement)
+  end
+
+  # @return [Fast::Node] the AST representation of the sql statement
+  # @example
+  # ast = Fast.parse_sql("select 'hello AST'")
+  #  => s(:select_stmt,
+  #       s(:target_list,
+  #         s(:res_target,
+  #           s(:val,
+  #             s(:a_const,
+  #               s(:val,
+  #                 s(:string,
+  #                   s(:str, "hello AST"))))))))
+  # `s` represents a Fast::Node with additional methods to access the tokens
+  # and location of the node.
+  # ast.search(:string).first.location.expression
+  #  => #<Fast::Source::Range (sql) 7...18>
+  def parse_sql(statement, buffer_name: "(sql)")
+    SQL.parse(statement, buffer_name: buffer_name)
+  end
+
+  # 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 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 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 # => #<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 < Fast::Source::Buffer
+      def tokens
+        @tokens ||= PgQuery.scan(source).first.tokens
+      end
+    end
+
+    # The SQL node is an AST node with additional tokenization info
+    class Node < Fast::Node
+
+      def first(pattern)
+        search(pattern).first
+      end
+
+      def replace(pattern, with=nil, &replacement)
+        replacement ||= -> (n) { replace(n.loc.expression, with) }
+        if root?
+          SQL.replace(pattern, self, &replacement)
+        else
+          parent.replace(pattern, &replacement)
+        end
+      end
+
+      def token
+        tokens.find{|e|e.start == location.begin}
+      end
+
+      def tokens
+        location.expression.source_buffer.tokens
+      end
+    end
+
+    module_function
+
+    # Parses SQL statements Using PGQuery
+    # @see sql_to_h
+    def parse(statement, buffer_name: "(sql)")
+      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|
+        from = stmt.stmt_location
+        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
+
+    # Clean up the hash structure returned by PgQuery
+    # @arg [Hash] hash the hash representation of the sql statement
+    # @return [Hash] the hash representation of the sql statement
+    def clean_structure(stmt)
+      res_hash = stmt.map do |key, value|
+        value = clean_structure(value) if value.is_a?(Hash)
+        value = value.map(&Fast::SQL.method(:clean_structure)) if value.is_a?(Array)
+        value = nil if [{}, [], "", :SETOP_NONE, :LIMIT_OPTION_DEFAULT, false].include?(value)
+        key = key.to_s.tr('-','_').to_sym
+        [key, value]
+      end
+      res_hash.to_h.compact
+    end
+
+    # Transform a sql tree into an AST.
+    # Populates the location of the AST nodes with the source map.
+    # @arg [Hash] obj the hash representation of the sql statement
+    # @return [Array] the AST representation of the sql statement
+    def sql_tree_to_ast(obj, source_buffer: nil, source_map: nil)
+      recursive = -> (e) { sql_tree_to_ast(e, source_buffer: source_buffer, source_map: source_map.dup) }
+      case obj
+      when Array
+        obj.map(&recursive).flatten.compact
+      when Hash
+        if (start = obj.delete(:location))
+          if (token = source_buffer.tokens.find{|e|e.start == start})
+            expression = Fast::Source.range(source_buffer, token.start, token.end)
+            source_map = Fast::Source.map(expression)
+          end
+        end
+        obj.map do |key, value|
+          children  = [*recursive.call(value)]
+          Node.new(key, children, location: source_map)
+        end.compact
+      else
+        obj
+      end
+    end
+  end
+end