ffast 0.2.2 → 0.2.4

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
-

data/lib/fast/summary.rb

@@ -0,0 +1,440 @@
+# frozen_string_literal: true
+
+require 'fast/prism_adapter'
+
+module Fast
+  class Summary
+    VISIBILITIES = %i[public protected private].freeze
+
+    def initialize(code_or_ast, file: nil, command_name: '.summary', level: nil)
+      @file = file
+      @command_name = command_name
+      @level = normalize_level(level)
+      @source =
+        if code_or_ast.is_a?(String)
+          code_or_ast
+        elsif code_or_ast.respond_to?(:loc) && code_or_ast.loc.respond_to?(:expression)
+          code_or_ast.loc.expression.source
+        end
+
+      @ast =
+        if unsupported_template?
+          nil
+        elsif code_or_ast.is_a?(String)
+          begin
+            Fast.parse_ruby(code_or_ast, buffer_name: file || '(string)')
+          rescue StandardError => e
+            warn "Error parsing #{file || 'source'}: #{e.message}" if Fast.debugging
+            nil
+          end
+        else
+          code_or_ast
+        end
+    end
+
+    def summarize
+      if @ast
+        print_node(@ast)
+      elsif unsupported_template?
+        puts "Unsupported template format for #{@command_name}: #{File.extname(@file)}"
+      else
+        puts "Unable to parse #{@file || 'source'} for #{@command_name}"
+      end
+    end
+
+    def outline
+      return [] unless @ast
+
+      top_level_nodes(@ast).filter_map { |node| outline_for(node) }
+    end
+
+    private
+
+    def unsupported_template?
+      @file && !File.extname(@file).empty? && File.extname(@file) != '.rb'
+    end
+
+    def print_node(node, indent = '')
+      return unless Fast.ast_node?(node)
+
+      case node.type
+      when :module
+        puts "#{indent}module #{node_source(node.children[0])}"
+        summarize_body(node.children[1], indent + '  ')
+        puts "#{indent}end"
+      when :class
+        name = node_source(node.children[0])
+        superclass = node.children[1] ? " < #{node_source(node.children[1])}" : ''
+        puts "#{indent}class #{name}#{superclass}"
+        summarize_body(node.children[2], indent + '  ')
+        puts "#{indent}end"
+      when :begin
+        summarize_body(node, indent)
+      else
+        summarize_body(node, indent)
+      end
+    end
+
+    def top_level_nodes(node)
+      return [] unless Fast.ast_node?(node)
+
+      case node.type
+      when :begin
+        node.children.select { |child| Fast.ast_node?(child) }
+      else
+        [node]
+      end
+    end
+
+    def outline_for(node)
+      return unless Fast.ast_node?(node)
+
+      case node.type
+      when :module
+        summary = build_summary(node.children[1])
+        build_outline_entry(node, summary, kind: :module, name: node_source(node.children[0]))
+      when :class
+        summary = build_summary(node.children[2])
+        build_outline_entry(node, summary,
+                            kind: :class,
+                            name: node_source(node.children[0]),
+                            superclass: node.children[1] && node_source(node.children[1]))
+      else
+        summary = build_summary(node)
+        build_outline_entry(node, summary, kind: node.type, name: node.type.to_s)
+      end
+    end
+
+    def build_outline_entry(node, summary, kind:, name:, superclass: nil)
+      {
+        file: @file,
+        kind: kind,
+        name: name,
+        superclass: superclass,
+        headline: outline_headline(kind, name, superclass),
+        constants: summary[:constants],
+        mixins: summary[:mixins],
+        relationships: summary[:relationships],
+        attributes: summary[:attributes],
+        scopes: summary[:scopes],
+        hooks: summary[:hooks],
+        validations: summary[:validations],
+        macros: summary[:macros],
+        requires: summary[:requires],
+        methods: summary[:methods],
+        nested: summary[:nested].filter_map { |child| outline_for(child) },
+        line: node.loc&.expression&.line
+      }
+    end
+
+    def outline_headline(kind, name, superclass)
+      case kind
+      when :module
+        "module #{name}"
+      when :class
+        superclass ? "class #{name} < #{superclass}" : "class #{name}"
+      else
+        name.to_s
+      end
+    end
+
+    def summarize_body(body, indent)
+      return unless Fast.ast_node?(body)
+
+      summary = build_summary(body)
+
+      if show_signals?
+        print_requires(summary[:requires], indent)
+        print_lines(summary[:constants], indent)
+        print_lines(summary[:mixins], indent)
+        print_lines(summary[:relationships], indent)
+        print_lines(summary[:attributes], indent)
+        print_section('Scopes', summary[:scopes], indent)
+        print_section('Hooks', summary[:hooks], indent)
+        print_section('Validations', summary[:validations], indent)
+        print_section('Macros', summary[:macros], indent)
+      end
+      print_methods(summary[:methods], indent) if show_methods?
+      summary[:nested].each { |child| print_node(child, indent) }
+    end
+
+    def build_summary(body)
+      summary = {
+        constants: [],
+        mixins: [],
+        relationships: [],
+        attributes: [],
+        scopes: [],
+        hooks: [],
+        validations: [],
+        macros: [],
+        requires: [],
+        methods: VISIBILITIES.to_h { |visibility| [visibility, []] },
+        nested: []
+      }
+
+      visibility = :public
+      body_nodes(body).each do |node|
+        next unless Fast.ast_node?(node)
+
+        case node.type
+        when :class, :module
+          summary[:nested] << node
+        when :casgn
+          summary[:constants] << constant_line(node)
+        when :def
+          summary[:methods][visibility] << method_signature(node)
+        when :defs
+          summary[:methods][visibility] << singleton_method_signature(node)
+        when :sclass
+          summarize_singleton_class(node, summary, visibility)
+        when :send
+          visibility = visibility_change(node) || visibility
+          categorize_send(node, summary)
+        end
+      end
+
+      summary
+    end
+
+    def summarize_singleton_class(node, summary, default_visibility)
+      visibility = default_visibility
+      body_nodes(node.children[1]).each do |child|
+        next unless Fast.ast_node?(child)
+
+        case child.type
+        when :def
+          summary[:methods][visibility] << "def self.#{method_signature(child).delete_prefix('def ')}"
+        when :send
+          visibility = visibility_change(child) || visibility
+          categorize_send(child, summary)
+        when :class, :module
+          summary[:nested] << child
+        when :casgn
+          summary[:constants] << constant_line(child)
+        end
+      end
+    end
+
+    def categorize_send(node, summary)
+      return unless node.type == :send && node.children[0].nil?
+
+      method_name = node.children[1]
+      if Fast.match?('(send nil {has_many belongs_to has_one has_and_belongs_to_many} ...)', node)
+        summary[:relationships] << compact_node_source(node)
+      elsif Fast.match?('(send nil {attr_accessor attr_reader attr_writer} ...)', node)
+        summary[:attributes] << attribute_line(node)
+      elsif Fast.match?('(send nil {include extend prepend} ...)', node)
+        summary[:mixins] << compact_node_source(node)
+      elsif Fast.match?('(send nil scope ...)', node)
+        summary[:scopes] << scope_line(node)
+      elsif Fast.match?('(send nil validates ...)', node)
+        summary[:validations] << node_source(node).delete_prefix('validates ')
+      elsif Fast.match?('(send nil validate ...)', node)
+        summary[:validations] << node_source(node).delete_prefix('validate ')
+      elsif Fast.match?('(send nil {require require_relative} (str _))', node)
+        summary[:requires] << required_path(node)
+      elsif Fast.match?('(send nil {private protected public})', node)
+        nil
+      else
+        summary[:hooks] << compact_node_source(node) if callback_macro?(method_name)
+        summary[:macros] << compact_node_source(node) if macro_candidate?(node, summary)
+      end
+    end
+
+    def macro_candidate?(node, summary)
+      return false unless node.type == :send && node.children[0].nil?
+
+      name = node.children[1]
+      return false if callback_macro?(name)
+      return false if Fast.match?('(send nil {has_many belongs_to has_one has_and_belongs_to_many} ...)', node)
+      return false if Fast.match?('(send nil {attr_accessor attr_reader attr_writer} ...)', node)
+      return false if Fast.match?('(send nil {include extend prepend} ...)', node)
+      return false if Fast.match?('(send nil {require require_relative} (str _))', node)
+      return false if Fast.match?('(send nil {scope validates validate private protected public} ...)', node)
+
+      !summary[:macros].include?(compact_node_source(node))
+    end
+
+    def callback_macro?(method_name)
+      method_name.to_s.start_with?('before_', 'after_', 'around_')
+    end
+
+    def visibility_change(node)
+      return unless node.type == :send && node.children[0].nil?
+      return unless VISIBILITIES.include?(node.children[1])
+      return unless node.children.length == 2
+
+      node.children[1]
+    end
+
+    def body_nodes(node)
+      return [] unless node
+      return node.children if node.type == :begin
+
+      [node]
+    end
+
+    def normalize_level(level)
+      return 3 if level.nil?
+
+      [[level.to_i, 1].max, 3].min
+    end
+
+    def show_signals?
+      @level >= 2
+    end
+
+    def show_methods?
+      @level >= 3
+    end
+
+    def constant_line(node)
+      lhs = node_source(node.children[0])
+      name = node.children[1]
+      rhs = node.children[2]
+      target = lhs.nil? || lhs.empty? || lhs == 'nil' ? name.to_s : "#{lhs}::#{name}"
+      rhs ? "#{target} = #{compact_value(rhs)}" : target
+    end
+
+    def attribute_line(node)
+      method_name, = captures_for('(send nil $_ ...)', node)
+      args = direct_symbol_arguments(node).map { |symbol| ":#{symbol}" }
+      "#{method_name} #{args.join(', ')}"
+    end
+
+    def required_path(node)
+      path_node = captures_for('(send nil $_ $(str _))', node).last
+      path_node.children.first.inspect
+    end
+
+    def scope_line(node)
+      name = captures_for('(send nil :scope (sym $_) ...)', node).first
+      lambda_node = captures_for('(send nil :scope (sym _) $({lambda block} ... ...))', node).first
+      args = lambda_args(lambda_node)
+      [name, args].join
+    end
+
+    def captures_for(pattern, node)
+      Fast.match?(pattern, node) || []
+    end
+
+    def lambda_args(node)
+      return '' unless Fast.ast_node?(node)
+      return '' unless node.type == :lambda || node.type == :block
+
+      args_node =
+        if node.type == :block
+          node.children.find { |child| Fast.match?('(args ...)', child) }
+        else
+          node.children[0]
+        end
+      return '' unless Fast.match?('(args ...)', args_node) || Fast.match?('(args)', args_node)
+      return '' if args_node.children.empty?
+
+      "(#{args_node.children.map { |arg| node_source(arg) }.join(', ')})"
+    end
+
+    def direct_symbol_arguments(node)
+      node.children.drop(2).filter_map do |child|
+        captures = captures_for('(sym $_)', child)
+        captures.first if captures.any?
+      end
+    end
+
+    def method_signature(node)
+      args = args_signature(node.children[1])
+      "def #{node.children[0]}#{args}"
+    end
+
+    def singleton_method_signature(node)
+      receiver = node_source(node.children[0])
+      args = args_signature(node.children[2])
+      "def #{receiver}.#{node.children[1]}#{args}"
+    end
+
+    def args_signature(args_node)
+      return '' unless Fast.match?('(args ...)', args_node) || Fast.match?('(args)', args_node)
+      return '' if args_node.children.empty?
+
+      "(#{args_node.children.map { |arg| node_source(arg) }.join(', ')})"
+    end
+
+    def compact_value(node)
+      return node_source(node) unless Fast.ast_node?(node)
+
+      case node.type
+      when :array
+        '[...]'
+      when :hash
+        '{...}'
+      when :block, :lambda
+        '{ ... }'
+      when :send
+        return compact_value(node.children[0]) if node.children[1] == :freeze && node.children.length == 2
+
+        node_source(node)
+      else
+        node_source(node)
+      end
+    end
+
+    def node_source(node)
+      return node.to_s unless Fast.ast_node?(node)
+
+      node.loc.expression.source
+    rescue StandardError
+      node.to_s
+    end
+
+    def compact_node_source(node)
+      source = node_source(node)
+      return source unless source.include?("\n")
+
+      head = source.lines.first.strip
+      if head.end_with?('do') || head.include?(' do')
+        "#{head} ... end"
+      else
+        "#{head} ..."
+      end
+    end
+
+    def print_requires(requires, indent)
+      return if requires.empty?
+
+      formatted = requires.map { |entry| entry.split(' ', 2).last }.join(', ')
+      puts "#{indent}requires: #{formatted}"
+      puts
+    end
+
+    def print_lines(lines, indent)
+      return if lines.empty?
+
+      puts
+      lines.each { |line| puts "#{indent}#{line}" }
+    end
+
+    def print_section(title, lines, indent)
+      return if lines.empty?
+
+      puts
+      joined = lines.join(', ')
+      if lines.one? || joined.length <= 100
+        puts "#{indent}#{title}: #{joined}"
+      else
+        puts "#{indent}#{title}:"
+        lines.each { |line| puts "#{indent}  #{line}" }
+      end
+    end
+
+    def print_methods(methods, indent)
+      VISIBILITIES.each do |visibility|
+        next if methods[visibility].empty?
+
+        puts
+        puts "#{indent}#{visibility}" unless visibility == :public
+        methods[visibility].each { |signature| puts "#{indent}#{'  ' unless visibility == :public}#{signature}" }
+      end
+    end
+  end
+end

data/lib/fast/version.rb

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