ffast 0.2.0 → 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,12 +64,14 @@ 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_link: false, show_sexp: false, file: nil, headless: false, bodyless: false, colorize: true) # rubocop:disable Metrics/ParameterLists
+  #   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)
       if show_link
         puts(result.link)
+      elsif show_permalink
+        puts(result.permalink)
       elsif !headless
         puts(highlight("# #{file}:#{line}", colorize: colorize))
       end
@@ -60,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
@@ -73,15 +107,24 @@ module Fast
           @show_sexp = true
         end
 
-        opts.on('--link', 'Print link to repository URL instead of code') do
+        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
@@ -99,24 +142,18 @@ module Fast
           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
@@ -151,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
@@ -181,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)
@@ -212,6 +268,7 @@ module Fast
       Fast.report(result,
                   file: file,
                   show_link: @show_link,
+                  show_permalink: @show_permalink,
                   show_sexp: @show_sexp,
                   headless: @headless,
                   bodyless: @bodyless,
@@ -222,8 +279,10 @@ module Fast
     # @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)

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
@@ -60,7 +65,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]

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.2.0'
+  VERSION = '0.2.2'
 end

data/lib/fast.rb

@@ -148,11 +148,22 @@ module Fast
 
     # @return [Fast::Node] parsed from file content
     # caches the content based on the filename.
+    # Also, it can parse SQL files.
     # @example
     #   Fast.ast_from_file("example.rb") # => s(...)
     def ast_from_file(file)
       @cache ||= {}
-      @cache[file] ||= ast(IO.read(file), buffer_name: file)
+      @cache[file] ||=
+        begin
+          method =
+            if file.end_with?('.sql')
+              require_relative 'fast/sql' unless respond_to?(:parse_sql)
+              :parse_sql
+            else
+              :ast
+            end
+          Fast.public_send(method, IO.read(file), buffer_name: file)
+        end
     end
 
     # Verify if a given AST matches with a specific pattern
@@ -169,7 +180,12 @@ module Fast
       node = ast_from_file(file)
       return [] unless node
 
-      search pattern, node
+      case node
+      when Array
+        node.map { |n| search(pattern, n) }.flatten.compact
+      else
+        search pattern, node
+      end
     end
 
     # Search with pattern on a directory or multiple files
@@ -228,8 +244,12 @@ module Fast
     def capture_file(pattern, file)
       node = ast_from_file(file)
       return [] unless node
-
-      capture pattern, node
+      case node
+      when Array
+        node.map { |n| capture(pattern, n) }.flatten.compact
+      else
+        capture pattern, node
+      end
     end
 
     # Search recursively into a node and its children.
@@ -241,9 +261,14 @@ module Fast
         yield node, match if block_given?
         match != true ? [node, match] : [node]
       else
-        node.each_child_node
-          .flat_map { |child| search(pattern, child, *args) }
-          .compact.flatten
+        case node
+        when Array
+          node.flat_map { |child| search(pattern, child, *args) }
+        else
+          node.each_child_node
+            .flat_map { |child| search(pattern, child, *args) }
+            .compact.flatten
+        end
       end
     end
 
@@ -435,6 +460,10 @@ module Fast
         node.type == expression.to_sym
       when String
         node == expression.to_s
+      when TrueClass
+        expression == :true
+      when FalseClass
+        expression == :false
       else
         node == expression
       end

data/mkdocs.yml

@@ -1,12 +1,18 @@
 site_name: Fast
 repo_url: https://github.com/jonatas/fast
 edit_uri: edit/master/docs/
-google_analytics: ['UA-125089529-1', 'auto']
+google_analytics: ['G-YKZDZDNRG2', 'auto']
+
 theme:
   name: material
   palette:
     primary: indigo
     accent: pink
+  logo: assets/logo.png
+  favicon: assets/favicon.png
+extra_css:
+  - stylesheets/custom.css
+
 markdown_extensions:
   - admonition
   - codehilite:
@@ -15,13 +21,16 @@ markdown_extensions:
       permalink: true
 nav:
   - Introduction: index.md
+  - Walkthrough: walkthrough.md
   - Syntax: syntax.md
   - Command Line: command_line.md
   - Experiments: experiments.md
   - Shortcuts: shortcuts.md
+  - Git Integration: git.md
   - Code Similarity: similarity_tutorial.md
   - Pry Integration: pry-integration.md
   - Editors' Integration: editors-integration.md
   - Research: research.md
   - Ideas: ideas.md
   - Videos: videos.md
+  - SQL Support: sql-support.md