ffast 0.1.9 → 0.2.2

data/lib/fast/cli.rb

@@ -2,6 +2,7 @@
 
 require 'fast'
 require 'fast/version'
+require 'fast/sql'
 require 'coderay'
 require 'optparse'
 require 'ostruct'
@@ -16,16 +17,44 @@ module Fast
   # Useful for printing code with syntax highlight.
   # @param show_sexp [Boolean] prints node expression instead of code
   # @param colorize [Boolean] skips `CodeRay` processing when false.
-  def highlight(node, show_sexp: false, colorize: true)
+  def highlight(node, show_sexp: false, colorize: true, sql: false)
     output =
       if node.respond_to?(:loc) && !show_sexp
-        node.loc.expression.source
+        wrap_source_range(node).source
       else
         node
       end
     return output unless colorize
 
-    CodeRay.scan(output, :ruby).term
+    CodeRay.scan(output, sql ? :sql : :ruby).term
+  end
+
+  # Fixes initial spaces to print the line since the beginning
+  # and fixes end of the expression including heredoc strings.
+  def wrap_source_range(node)
+    expression = node.loc.expression
+    Parser::Source::Range.new(
+      expression.source_buffer,
+      first_position_from_expression(node),
+      last_position_from_expression(node) || expression.end_pos
+    )
+  end
+
+  # If a method call contains a heredoc, it should print the STR around it too.
+  def last_position_from_expression(node)
+    internal_heredoc = node.each_descendant(:str).select { |n| n.loc.respond_to?(:heredoc_end) }
+    internal_heredoc.map { |n| n.loc.heredoc_end.end_pos }.max if internal_heredoc.any?
+  end
+
+  # If a node is the first on it's line, print since the beginning of the line
+  # to show the proper whitespaces for identing the next lines of the code.
+  def first_position_from_expression(node)
+    expression = node.loc.expression
+    if node.parent && node.parent.loc.expression.line != expression.line
+      expression.begin_pos - expression.column
+    else
+      expression.begin_pos
+    end
   end
 
   # Combines {.highlight} with files printing file name in the head with the
@@ -35,13 +64,19 @@ module Fast
   # @param file [String] Show the file name and result line before content
   # @param headless [Boolean] Skip printing the file name and line before content
   # @example
-  #   Fast.highlight(Fast.search(...))
-  def report(result, show_sexp: false, file: nil, headless: false, colorize: true)
+  #   Fast.report(result, file: 'file.rb')
+  def report(result, show_link: false, show_permalink: false, show_sexp: false, file: nil, headless: false, bodyless: false, colorize: true) # rubocop:disable Metrics/ParameterLists
     if file
       line = result.loc.expression.line if result.is_a?(Parser::AST::Node)
-      puts(highlight("# #{file}:#{line}", colorize: colorize)) unless headless
+      if show_link
+        puts(result.link)
+      elsif show_permalink
+        puts(result.permalink)
+      elsif !headless
+        puts(highlight("# #{file}:#{line}", colorize: colorize))
+      end
     end
-    puts highlight(result, show_sexp: show_sexp, colorize: colorize)
+    puts(highlight(result, show_sexp: show_sexp, colorize: colorize)) unless bodyless
   end
 
   # Command Line Interface for Fast
@@ -56,6 +91,9 @@ module Fast
       option_parser.parse! args
 
       @files = [*@files].reject { |arg| arg.start_with?('-') }
+      @sql ||= @files.any? && @files.all? { |file| file.end_with?('.sql') }
+
+      require 'fast/sql' if @sql
     end
 
     def option_parser # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
@@ -69,10 +107,24 @@ module Fast
           @show_sexp = true
         end
 
+        opts.on('--link', 'Print link to repository URL') do
+          require 'fast/git'
+          @show_link = true
+        end
+
+        opts.on('--permalink', 'Print permalink to repository URL') do
+          require 'fast/git'
+          @show_permalink = true
+        end
+
         opts.on('-p', '--parallel', 'Paralelize search') do
           @parallel = true
         end
 
+        opts.on("--sql", "Use SQL instead of Ruby") do
+          @sql = true
+        end
+
         opts.on('--captures', 'Print only captures of the patterns and skip node results') do
           @captures = true
         end
@@ -81,29 +133,27 @@ module Fast
           @headless = true
         end
 
+        opts.on('--bodyless', 'Print results without the code details') do
+          @bodyless = true
+        end
+
         opts.on('--pry', 'Jump into a pry session with results') do
           @pry = true
           require 'pry'
         end
 
-        opts.on('-c', '--code', 'Create a pattern from code example') do
-          if @pattern
-            @from_code = true
-            @pattern = Fast.ast(@pattern).to_sexp
-            debug 'Expression from AST:', @pattern
-          end
-        end
-
         opts.on('-s', '--similar', 'Search for similar code.') do
           @similar = true
-          @pattern = Fast.expression_from(Fast.ast(@pattern))
-          debug "Looking for code similar to #{@pattern}"
         end
 
         opts.on('--no-color', 'Disable color output') do
           @colorize = false
         end
 
+        opts.on('--from-code', 'From code') do
+          @from_code = true
+        end
+
         opts.on_tail('--version', 'Show version') do
           puts Fast::VERSION
           exit
@@ -116,12 +166,13 @@ module Fast
     end
 
     def replace_args_with_shortcut(args)
-      shortcut = find_shortcut args.first[1..-1]
+      shortcut = find_shortcut args.first[1..]
+
       if shortcut.single_run_with_block?
         shortcut.run
         exit
       else
-        args.one? ? shortcut.args : shortcut.merge_args(args[1..-1])
+        args.one? ? shortcut.args : shortcut.merge_args(args[1..])
       end
     end
 
@@ -137,6 +188,25 @@ module Fast
 
       if @help || @files.empty? && @pattern.nil?
         puts option_parser.help
+        return
+      end
+
+      if @similar
+        ast = Fast.public_send( @sql ? :parse_sql : :ast, @pattern)
+        @pattern = Fast.expression_from(ast)
+        debug "Search similar to #{@pattern}"
+      elsif @from_code
+        ast = Fast.public_send( @sql ? :parse_sql : :ast, @pattern)
+        @pattern = ast.to_sexp
+        if @sql
+          @pattern.gsub!(/\b-\b/,'_')
+        end
+        debug "Search from code to #{@pattern}"
+      end
+
+      if @files.empty?
+        ast ||= Fast.public_send( @sql ? :parse_sql : :ast, @pattern)
+        puts Fast.highlight(ast, show_sexp: @show_sexp, colorize: @colorize, sql: @sql)
       else
         search
       end
@@ -167,7 +237,7 @@ module Fast
     # @yieldparam [String, Array] with file and respective search results
     def execute_search(&on_result)
       Fast.public_send(search_method_name,
-                       expression,
+                       @pattern,
                        @files,
                        parallel: parallel?,
                        on_result: on_result)
@@ -195,18 +265,26 @@ module Fast
     # Report results using the actual options binded from command line.
     # @see Fast.report
     def report(file, result)
-      Fast.report(result, file: file, show_sexp: @show_sexp, headless: @headless, colorize: @colorize)
+      Fast.report(result,
+                  file: file,
+                  show_link: @show_link,
+                  show_permalink: @show_permalink,
+                  show_sexp: @show_sexp,
+                  headless: @headless,
+                  bodyless: @bodyless,
+                  colorize: @colorize)
     end
 
     # Find shortcut by name. Preloads all `Fastfiles` before start.
     # @param name [String]
     # @return [Fast::Shortcut]
     def find_shortcut(name)
-      require 'fast/shortcut'
-      Fast.load_fast_files!
+      unless defined? Fast::Shortcut
+        require 'fast/shortcut'
+        Fast.load_fast_files!
+      end
 
       shortcut = Fast.shortcuts[name] || Fast.shortcuts[name.to_sym]
-
       shortcut || exit_shortcut_not_found(name)
     end
 

data/lib/fast/experiment.rb

@@ -290,7 +290,7 @@ module Fast
       Fast.search(experiment.expression, @ast) || []
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
     #
     # Execute partial replacements generating new file with the
     # content replaced.
@@ -312,7 +312,6 @@ module Fast
       new_content
     end
 
-    # rubocop:enable Metrics/AbcSize
     # rubocop:enable Metrics/MethodLength
 
     # Write new file name depending on the combination

data/lib/fast/git.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Git plugin for Fast::Node.
+# It allows to easily access metadata from current file.
+module Fast
+  # This is not required by default, so to use it, you should require it first.
+  #
+  #  @example
+  #    require 'fast/git'
+  #    Fast.ast_from_file('lib/fast.rb').git_log.first.author.name # => "Jonatas Davi Paganini"
+  class Node < Astrolabe::Node
+    # @return [Git::Base] from current directory
+    def git
+      require 'git' unless defined? Git
+      Git.open('.')
+    end
+
+    # @return [Git::Object::Blob] from current #buffer_name
+    def git_blob
+      return unless from_file?
+
+      git.gblob(buffer_name)
+    end
+
+    # @return [Git::Log] from the current #git_blob
+    #  buffer-name
+    def git_log
+      git_blob.log
+    end
+
+    # @return [Git::Object::Commit]
+    def last_commit
+      git_log.first
+    end
+
+    # @return [String] with last commit SHA
+    def sha
+      last_commit.sha
+    end
+
+    # @return [String] with remote URL
+    def remote_url
+      git.remote.url
+    end
+
+    # Given #remote_url is "git@github.com:namespace/project.git"
+    # Or #remote_url is "https://github.com/namespace/project.git"
+    # @return [String] "https://github.com/namespace/project"
+    def project_url
+      return remote_url.gsub(/\.git$/, '') if remote_url.start_with?('https')
+
+      remote_url
+        .gsub('git@', 'https://')
+        .gsub(/:(\w)/, '/\\1')
+        .gsub(/\.git$/, '')
+    end
+
+    def file
+      buffer_name.gsub("#{Dir.pwd}/", '')
+    end
+
+    # @return
+    def line_range
+      lines.map { |l| "L#{l}" }.join('-')
+    end
+
+    # @return [Array] with lines range
+    def lines
+      exp = loc.expression
+      first_line = exp.first_line
+      last_line = exp.last_line
+      [first_line, last_line].uniq
+    end
+
+    # @return [Integer] lines of code from current block
+    def lines_of_code
+      lines.last - lines.first + 1
+    end
+
+    # @return [String] a markdown link with #md_link_description and #link
+    def md_link(text = md_link_description)
+      "[#{text}](#{link})"
+    end
+
+    # @return [String] with the source cutting arguments from method calls to be
+    # able to create a markdown link without parens.
+    def md_link_description
+      source[/([^\r\(]+)\(/, 1] || source
+    end
+
+    # @return [String] with formatted repositorym link
+    def link
+      "#{project_url}/blob/master/#{buffer_name}##{line_range}"
+    end
+
+    # @return [String] with permanent link to the actual commit
+    def permalink
+      "#{project_url}/blob/#{sha}/#{buffer_name}##{line_range}"
+    end
+  end
+end

data/lib/fast/shortcut.rb

@@ -7,7 +7,12 @@ 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__), '..', '..')
+    ].compact.map(&File.method(:expand_path)).uniq.freeze
 
     # Store predefined searches with default paths through shortcuts.
     # define your Fastfile in you root folder or
@@ -29,7 +34,7 @@ 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
@@ -54,19 +59,16 @@ module Fast
       @block && @args.nil?
     end
 
-    def options
-      @args.select { |arg| arg.start_with? '-' }
-    end
-
-    def params
-      @args - options
-    end
-
     # Merge extra arguments from input returning a new arguments array keeping
     # the options from previous alias and replacing the files with the
     # @param [Array] extra_args
     def merge_args(extra_args)
-      [params[0], *options, *extra_args.select(&File.method(:exists?))]
+      all_args = (@args + extra_args).uniq
+      options = all_args.select { |arg| arg.start_with? '-' }
+      files = extra_args.select(&File.method(:exist?))
+      command = (@args - options - files).first
+
+      [command, *options, *files]
     end
 
     # If the shortcut was defined with a single block and no extra arguments, it

data/lib/fast/sql/rewriter.rb

@@ -0,0 +1,69 @@
+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)
+        sql_rewriter_for(pattern, ast, &replacement).rewrite!
+      end
+
+      # @return [Fast::SQL::Rewriter]
+      # @see Fast::Rewriter
+      def sql_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
+
+      # @return [Array<Symbol>] with all types that matches
+      def types
+        ast.type
+      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
+      # 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|
+              # 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|
+                @match_index += 1
+                execute_replacement(node, nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast/sql.rb

@@ -0,0 +1,167 @@
+require 'pg_query'
+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 which is a subclass of Parser::AST::Node and
+  # has additional methods to access the tokens and location of the node.
+  # ast.search(:string).first.location.expression
+  #  => #<Parser::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 Parser::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
+    # 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.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
+      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
+      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)
+      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 = Parser::Source::Range.new(source_buffer, token.start, token.end)
+            source_map = Parser::Source::Map.new(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
+

data/lib/fast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fast
-  VERSION = '0.1.9'
+  VERSION = '0.2.2'
 end