ffast 0.2.0 → 0.2.3

data/lib/fast/prism_adapter.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'fast/source'
+
+module Fast
+  module PrismAdapter
+    module_function
+
+    class Location
+      attr_accessor :node
+      attr_reader :expression
+
+      def initialize(buffer_name, source, start_offset, end_offset, prism_node: nil)
+        @buffer_name = buffer_name
+        @source = source
+        @prism_node = prism_node
+        buffer = Fast::Source.buffer(buffer_name, source: source)
+        @expression = Fast::Source.range(
+          buffer,
+          character_offset(source, start_offset),
+          character_offset(source, end_offset)
+        )
+      end
+
+      def name
+        return unless @prism_node&.respond_to?(:name_loc) && @prism_node.name_loc
+
+        range_for(@prism_node.name_loc)
+      end
+
+      def selector
+        return unless @prism_node&.respond_to?(:message_loc) && @prism_node.message_loc
+
+        range_for(@prism_node.message_loc)
+      end
+
+      def operator
+        return unless @prism_node&.respond_to?(:operator_loc) && @prism_node.operator_loc
+
+        range_for(@prism_node.operator_loc)
+      end
+
+      private
+
+      def character_offset(source, byte_offset)
+        source.byteslice(0, byte_offset).to_s.length
+      end
+
+      def range_for(prism_location)
+        buffer = Fast::Source.buffer(@buffer_name, source: @source)
+        Fast::Source.range(
+          buffer,
+          character_offset(@source, prism_location.start_offset),
+          character_offset(@source, prism_location.end_offset)
+        )
+      end
+    end
+
+    class Node < Fast::Node
+      def initialize(type, children:, loc:)
+        super(type, Array(children), location: loc)
+      end
+
+      def updated(type = nil, children = nil, properties = nil)
+        self.class.new(
+          type || self.type,
+          children: children || self.children,
+          loc: properties&.fetch(:location, loc) || loc
+        )
+      end
+    end
+
+    def parse(source, buffer_name: '(string)')
+      result = Prism.parse(source)
+      return unless result.success?
+
+      adapt(result.value, source, buffer_name)
+    end
+
+    def adapt(node, source, buffer_name)
+      return if node.nil?
+
+      case node
+      when Prism::ProgramNode
+        statements = adapt_statements(node.statements, source, buffer_name)
+        statements.is_a?(Node) ? statements : build_node(:begin, statements, node, source, buffer_name)
+      when Prism::StatementsNode
+        adapt_statements(node, source, buffer_name)
+      when Prism::ModuleNode
+        build_node(:module, [adapt(node.constant_path, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::ClassNode
+        build_node(:class, [adapt(node.constant_path, source, buffer_name), adapt(node.superclass, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::SingletonClassNode
+        build_node(:sclass, [adapt(node.expression, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::DefNode
+        if node.receiver
+          build_node(:defs, [adapt(node.receiver, source, buffer_name), node.name, adapt_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+        else
+          build_node(:def, [node.name, adapt_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+        end
+      when Prism::BlockNode
+        return nil unless node.respond_to?(:call)
+
+        build_node(:block, [adapt_call_node(node.call, source, buffer_name), adapt_block_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      when Prism::CallNode
+        if node.respond_to?(:block) && node.block.is_a?(Prism::BlockNode)
+          return build_node(
+            :block,
+            [
+              adapt_call_node(node, source, buffer_name),
+              adapt_block_parameters(node.block.parameters, source, buffer_name),
+              adapt(node.block.body, source, buffer_name)
+            ],
+            node,
+            source,
+            buffer_name
+          )
+        end
+
+        adapt_call_node(node, source, buffer_name)
+      when Prism::ParenthesesNode
+        adapt(node.body, source, buffer_name)
+      when Prism::RangeNode
+        build_node(node.exclude_end? ? :erange : :irange, [adapt(node.left, source, buffer_name), adapt(node.right, source, buffer_name)], node, source, buffer_name)
+      when Prism::BlockArgumentNode
+        build_node(:block_pass, [adapt(node.expression, source, buffer_name)], node, source, buffer_name)
+      when Prism::ConstantPathNode
+        build_const_path(node, source, buffer_name)
+      when Prism::ConstantReadNode
+        build_node(:const, [nil, node.name], node, source, buffer_name)
+      when Prism::ConstantWriteNode
+        build_node(:casgn, [nil, node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::SymbolNode
+        build_node(:sym, [node.unescaped], node, source, buffer_name)
+      when Prism::StringNode
+        build_node(:str, [node.unescaped], node, source, buffer_name)
+      when Prism::InterpolatedStringNode
+        build_node(:dstr, node.parts.filter_map { |part| adapt(part, source, buffer_name) }, node, source, buffer_name)
+      when Prism::InterpolatedSymbolNode
+        build_node(:dsym, node.parts.filter_map { |part| adapt(part, source, buffer_name) }, node, source, buffer_name)
+      when Prism::ArrayNode
+        build_node(:array, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+      when Prism::HashNode
+        build_node(:hash, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+      when Prism::KeywordHashNode
+        build_node(:hash, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+      when Prism::AssocNode
+        build_node(:pair, [adapt(node.key, source, buffer_name), adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::SelfNode
+        build_node(:self, [], node, source, buffer_name)
+      when Prism::LocalVariableReadNode
+        build_node(:lvar, [node.name], node, source, buffer_name)
+      when Prism::InstanceVariableReadNode
+        build_node(:ivar, [node.name], node, source, buffer_name)
+      when Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode
+        build_node(:ivasgn, [node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::LocalVariableWriteNode, Prism::LocalVariableOrWriteNode
+        build_node(:lvasgn, [node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::LocalVariableOperatorWriteNode
+        build_node(
+          :op_asgn,
+          [
+            build_node(:lvasgn, [node.name], node, source, buffer_name),
+            (node.respond_to?(:binary_operator) ? node.binary_operator : node.operator),
+            adapt(node.value, source, buffer_name)
+          ],
+          node,
+          source,
+          buffer_name
+        )
+      when Prism::IntegerNode
+        build_node(:int, [node.value], node, source, buffer_name)
+      when Prism::FloatNode
+        build_node(:float, [node.value], node, source, buffer_name)
+      when Prism::TrueNode
+        build_node(:true, [], node, source, buffer_name)
+      when Prism::FalseNode
+        build_node(:false, [], node, source, buffer_name)
+      when Prism::NilNode
+        build_node(:nil, [], node, source, buffer_name)
+      when Prism::IfNode
+        build_node(:if, [adapt(node.predicate, source, buffer_name), adapt(node.statements, source, buffer_name), adapt(node.consequent, source, buffer_name)], node, source, buffer_name)
+      when Prism::UnlessNode
+        build_node(:if, [adapt(node.predicate, source, buffer_name), adapt(node.consequent, source, buffer_name), adapt(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::CaseNode
+        children = [adapt(node.predicate, source, buffer_name)]
+        children.concat(node.conditions.map { |condition| adapt(condition, source, buffer_name) })
+        else_clause =
+          if node.respond_to?(:else_clause)
+            node.else_clause
+          elsif node.respond_to?(:consequent)
+            node.consequent
+          end
+        children << adapt_else_clause(else_clause, source, buffer_name) if else_clause
+        build_node(:case, children, node, source, buffer_name)
+      when Prism::WhenNode
+        condition =
+          if node.conditions.length == 1
+            adapt(node.conditions.first, source, buffer_name)
+          else
+            build_node(:array, node.conditions.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
+          end
+        build_node(:when, [condition, adapt(node.statements, source, buffer_name)].compact, node, source, buffer_name)
+      when Prism::ElseNode
+        adapt_else_clause(node, source, buffer_name)
+      when Prism::BeginNode, Prism::EmbeddedStatementsNode
+        statements = adapt_statements(node.statements, source, buffer_name)
+        children = statements.is_a?(Node) && statements.type == :begin ? statements.children : Array(statements)
+        build_node(:begin, children, node, source, buffer_name)
+      when Prism::EmbeddedVariableNode
+        build_node(:begin, [adapt(node.variable, source, buffer_name)].compact, node, source, buffer_name)
+      when Prism::LambdaNode
+        build_node(:lambda, [adapt_block_parameters(node.parameters, source, buffer_name), adapt(node.body, source, buffer_name)], node, source, buffer_name)
+      else
+        nil
+      end
+    end
+
+    def adapt_statements(node, source, buffer_name)
+      return nil unless node
+
+      children = node.body.filter_map { |child| adapt(child, source, buffer_name) }
+      return nil if children.empty?
+      return children.first if children.one?
+
+      build_node(:begin, children, node, source, buffer_name)
+    end
+
+    def adapt_parameters(node, source, buffer_name)
+      return build_node(:args, [], nil, source, buffer_name) unless node
+
+      children = []
+      children.concat(node.requireds.map { |child| build_node(:arg, [child.name], child, source, buffer_name) }) if node.respond_to?(:requireds)
+      children.concat(node.optionals.map { |child| build_node(:optarg, [child.name, adapt(child.value, source, buffer_name)], child, source, buffer_name) }) if node.respond_to?(:optionals)
+      children << build_node(:restarg, [parameter_name(node.rest)], node.rest, source, buffer_name) if node.respond_to?(:rest) && node.rest
+      children.concat(node.posts.map { |child| build_node(:arg, [child.name], child, source, buffer_name) }) if node.respond_to?(:posts)
+      children.concat(node.keywords.map { |child| adapt_keyword_parameter(child, source, buffer_name) }) if node.respond_to?(:keywords)
+      children << build_node(:kwrestarg, [parameter_name(node.keyword_rest)], node.keyword_rest, source, buffer_name) if node.respond_to?(:keyword_rest) && node.keyword_rest
+      children << build_node(:blockarg, [parameter_name(node.block)], node.block, source, buffer_name) if node.respond_to?(:block) && node.block
+      build_node(:args, children, node, source, buffer_name)
+    end
+
+    def adapt_block_parameters(node, source, buffer_name)
+      return build_node(:args, [], nil, source, buffer_name) unless node
+
+      params = node.respond_to?(:parameters) ? node.parameters : node
+      adapt_parameters(params, source, buffer_name)
+    end
+
+    def adapt_keyword_parameter(node, source, buffer_name)
+      case node
+      when Prism::RequiredKeywordParameterNode
+        build_node(:kwarg, [node.name], node, source, buffer_name)
+      when Prism::OptionalKeywordParameterNode
+        build_node(:kwoptarg, [node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      else
+        build_node(:arg, [node.name], node, source, buffer_name)
+      end
+    end
+
+    def adapt_call_node(node, source, buffer_name)
+      children = [adapt(node.receiver, source, buffer_name), node.name]
+      children.concat(node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) } || [])
+      children << adapt(node.block, source, buffer_name) if node.respond_to?(:block) && node.block && !node.block.is_a?(Prism::BlockNode)
+      return build_node(:send, children, node, source, buffer_name) unless node.respond_to?(:block) && node.block.is_a?(Prism::BlockNode)
+
+      end_offset = node.block.location.start_offset
+      while end_offset > node.location.start_offset && source.byteslice(end_offset - 1, 1)&.match?(/\s/)
+        end_offset -= 1
+      end
+
+      loc = Location.new(
+        buffer_name,
+        source,
+        node.location.start_offset,
+        end_offset,
+        prism_node: node
+      )
+      send_node = Node.new(:send, children: children, loc: loc)
+      loc.node = send_node
+      send_node
+    end
+
+    def adapt_else_clause(node, source, buffer_name)
+      adapt(node.statements, source, buffer_name)
+    end
+
+    def parameter_name(node)
+      node.respond_to?(:name) ? node.name : nil
+    end
+
+    def build_const_path(node, source, buffer_name)
+      parent = node.parent ? adapt(node.parent, source, buffer_name) : nil
+      build_node(:const, [parent, node.child.name], node, source, buffer_name)
+    end
+
+    def build_node(type, children, prism_node, source, buffer_name)
+      loc =
+        if prism_node
+          Location.new(buffer_name, source, prism_node.location.start_offset, prism_node.location.end_offset, prism_node: prism_node)
+        else
+          Location.new(buffer_name, source, 0, 0)
+        end
+      node = Node.new(type, children: children, loc: loc)
+      loc.node = node
+      node
+    end
+  end
+end

data/lib/fast/rewriter.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require 'fast/source'
+require_relative 'source_rewriter'
+
 # Rewriter loads a set of methods related to automated replacement using
 # expressions and custom blocks of code.
 module Fast
   class << self
     # Replaces content based on a pattern.
-    # @param [Astrolabe::Node] ast with the current AST to search.
+    # @param [Fast::Node] ast with the current AST to search.
     # @param [String] pattern with the expression to be targeting nodes.
     # @param [Proc] replacement gives the [Rewriter] context in the block.
     # @example
@@ -15,7 +18,9 @@ module Fast
     # @return [String] with the new source code after apply the replacement
     # @see Fast::Rewriter
     def replace(pattern, ast, source = nil, &replacement)
-      rewriter_for(pattern, ast, source, &replacement).rewrite!
+      rewritten = rewriter_for(pattern, ast, source, &replacement).rewrite!
+      Fast.validate_ruby!(rewritten, buffer_name: ast.buffer_name) if rewritten
+      rewritten
     end
 
     # @return [Fast::Rewriter]
@@ -54,12 +59,11 @@ module Fast
   #    rewriter.search ='(lvasgn _ ...)'
   #    rewriter.replacement =  -> (node) { replace(node.location.name, 'variable_renamed') }
   #    rewriter.rewrite! # => "variable_renamed = 1"
-  class Rewriter < Parser::TreeRewriter
+  class Rewriter
     # @return [Integer] with occurrence index
     attr_reader :match_index
     attr_accessor :search, :replacement, :source, :ast
     def initialize(*_args)
-      super()
       @match_index = 0
     end
 
@@ -69,14 +73,18 @@ module Fast
     end
 
     def buffer
-      buffer = Parser::Source::Buffer.new('replacement')
-      buffer.source = source || ast.loc.expression.source
-      buffer
+      Fast::Source.buffer('replacement', source: source || ast.loc.expression.source)
+    end
+
+    def rewrite(source_buffer, root)
+      @source_rewriter = Fast::SourceRewriter.new(source_buffer)
+      traverse(root)
+      @source_rewriter.process
     end
 
     # @return [Array<Symbol>] with all types that matches
     def types
-      Fast.search(search, ast).grep(Parser::AST::Node).map(&:type).uniq
+      Fast.search(search, ast).select { |node| Fast.ast_node?(node) }.map(&:type).uniq
     end
 
     def match?(node)
@@ -92,13 +100,33 @@ module Fast
             @match_index += 1
             execute_replacement(node, captures)
           end
-          super(node)
+          traverse_children(node)
         end
       end
     end
 
+    def remove(range)
+      @source_rewriter.remove(range)
+    end
+
+    def wrap(range, before, after)
+      @source_rewriter.wrap(range, before, after)
+    end
+
+    def insert_before(range, content)
+      @source_rewriter.insert_before(range, content)
+    end
+
+    def insert_after(range, content)
+      @source_rewriter.insert_after(range, content)
+    end
+
+    def replace(range, content)
+      @source_rewriter.replace(range, content)
+    end
+
     # Execute {#replacement} block
-    # @param [Astrolabe::Node] node that will be yield in the replacement block
+    # @param [Fast::Node] node that will be yield in the replacement block
     # @param [Array<Object>, nil] captures are yield if {#replacement} take second argument.
     def execute_replacement(node, captures)
       if replacement.parameters.length == 1
@@ -107,5 +135,31 @@ module Fast
         instance_exec node, captures, &replacement
       end
     end
+
+    private
+
+    def traverse(node)
+      return if node.nil?
+
+      if node.is_a?(Array)
+        node.each { |child| traverse(child) }
+        return
+      end
+
+      return unless Fast.ast_node?(node)
+
+      handler = :"on_#{node.type}"
+      if respond_to?(handler, true)
+        public_send(handler, node)
+      else
+        traverse_children(node)
+      end
+    end
+
+    def traverse_children(node)
+      node.children.each do |child|
+        traverse(child) if Fast.ast_node?(child) || child.is_a?(Array)
+      end
+    end
   end
 end

data/lib/fast/scan.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Fast
+  class Scan
+    GROUPS = {
+      models: 'Models',
+      controllers: 'Controllers',
+      services: 'Services',
+      jobs: 'Jobs',
+      mailers: 'Mailers',
+      libraries: 'Libraries',
+      other: 'Other'
+    }.freeze
+
+    MAX_METHODS = 5
+    MAX_SIGNALS = 4
+    MAX_MACROS = 3
+
+    def initialize(locations, command_name: '.scan', level: nil)
+      @locations = Array(locations)
+      @command_name = command_name
+      @level = normalize_level(level)
+    end
+
+    def scan
+      files = Fast.ruby_files_from(*@locations)
+      grouped = files.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |file, memo|
+        entries = flatten_entries(Fast.summary(IO.read(file), file: file, command_name: @command_name).outline)
+        next if entries.empty?
+
+        memo[classify(file, entries)] << [file, entries]
+      end
+
+      print_grouped(grouped)
+    end
+
+    private
+
+    def classify(file, entries)
+      entries = structural_entries(entries)
+
+      return :models if file.include?('/models/') || model_like?(entries)
+      return :controllers if file.include?('/controllers/') || controller_like?(entries)
+      return :services if file.include?('/services/') || name_like?(entries, /Service\z/)
+      return :jobs if file.include?('/jobs/') || name_like?(entries, /Job\z/)
+      return :mailers if file.include?('/mailers/') || name_like?(entries, /Mailer\z/)
+      return :libraries if file.start_with?('lib/')
+
+      :other
+    end
+
+    def model_like?(entries)
+      entries.any? do |entry|
+        superclass = entry[:superclass].to_s
+        superclass.end_with?('ApplicationRecord', 'ActiveRecord::Base') ||
+          entry[:relationships].any? ||
+          entry[:validations].any? ||
+          entry[:scopes].any?
+      end
+    end
+
+    def controller_like?(entries)
+      entries.any? do |entry|
+        superclass = entry[:superclass].to_s
+        superclass.end_with?('Controller', 'BaseController', 'ApplicationController') ||
+          entry[:hooks].any? { |hook| hook.include?('_action') }
+      end
+    end
+
+    def name_like?(entries, pattern)
+      entries.any? { |entry| entry[:name].to_s.match?(pattern) }
+    end
+
+    def print_grouped(grouped)
+      GROUPS.each do |key, label|
+        files = grouped[key]
+        next if files.empty?
+
+        puts "#{label}:"
+        files.sort_by(&:first).each do |file, entries|
+          print_file(file, entries)
+        end
+        puts
+      end
+    end
+
+    def print_file(file, entries)
+      entries = structural_entries(entries)
+      return if entries.empty?
+
+      puts "- #{file}"
+      entries.each do |entry|
+        puts "  #{object_signature(entry)}"
+
+        signals = build_signals(entry)
+        puts "  signals: #{signals.join(' | ')}" if show_signals? && signals.any?
+
+        methods = build_methods(entry)
+        puts "  methods: #{methods.join(', ')}" if show_methods? && methods.any?
+      end
+    end
+
+    def structural_entries(entries)
+      filtered = entries.select do |entry|
+        %i[module class].include?(entry[:kind]) && interesting_entry?(entry)
+      end
+      filtered.empty? ? entries.reject { |entry| entry[:kind] == :send } : filtered
+    end
+
+    def flatten_entries(entries, namespace = nil)
+      entries.flat_map do |entry|
+        qualified_name = qualify_name(namespace, entry[:name])
+        flattened_entry = entry.merge(
+          name: qualified_name,
+          nested: []
+        )
+
+        [flattened_entry] + flatten_entries(entry[:nested], qualified_name)
+      end
+    end
+
+    def qualify_name(namespace, name)
+      return name unless namespace && name
+      return name if name.include?('::')
+
+      "#{namespace}::#{name}"
+    end
+
+    def interesting_entry?(entry)
+      entry[:methods].values.any?(&:any?) ||
+        entry[:relationships].any? ||
+        entry[:hooks].any? ||
+        entry[:validations].any? ||
+        entry[:scopes].any? ||
+        entry[:macros].any? ||
+        entry[:mixins].any?
+    end
+
+    def object_signature(entry)
+      signature = entry[:name].to_s
+      return signature unless entry[:kind] == :class && entry[:superclass]
+
+      "#{signature} < #{entry[:superclass]}"
+    end
+
+    def build_signals(entry)
+      signals = []
+      signals << summarize_section('relationships', entry[:relationships]) if entry[:relationships].any?
+      signals << summarize_section('hooks', entry[:hooks]) if entry[:hooks].any?
+      signals << summarize_section('validations', entry[:validations]) if entry[:validations].any?
+      signals << summarize_section('scopes', entry[:scopes]) if entry[:scopes].any?
+      signals << summarize_section('macros', entry[:macros], limit: MAX_MACROS) if entry[:macros].any?
+      signals << summarize_section('mixins', entry[:mixins]) if entry[:mixins].any?
+      signals.first(MAX_SIGNALS)
+    end
+
+    def summarize_section(name, values, limit: 2)
+      preview = values.first(limit).join(', ')
+      suffix = values.length > limit ? ", +#{values.length - limit}" : ''
+      "#{name}=#{preview}#{suffix}"
+    end
+
+    def build_methods(entry)
+      public_methods = entry[:methods][:public].first(MAX_METHODS)
+      protected_methods = entry[:methods][:protected].first(2)
+      private_methods = entry[:methods][:private].first(2)
+
+      methods = public_methods.map { |method| qualify_method(entry, method) }
+      methods.concat(protected_methods.map { |method| "protected #{qualify_method(entry, method)}" })
+      methods.concat(private_methods.map { |method| "private #{qualify_method(entry, method)}" })
+      methods
+    end
+
+    def qualify_method(entry, signature)
+      method = signature.delete_prefix('def ')
+      separator = singleton_method?(method) || module_function_entry?(entry) ? '.' : '#'
+      method = method.delete_prefix('self.')
+      "#{entry[:name]}#{separator}#{method}"
+    end
+
+    def singleton_method?(method)
+      method.start_with?('self.')
+    end
+
+    def module_function_entry?(entry)
+      entry[:kind] == :module && entry[:macros].include?('module_function')
+    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
+  end
+end