ffast 0.2.2 → 0.2.4

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,207 @@
+# 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|
+        begin
+          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]
+        rescue StandardError => e
+          warn "Error scanning #{file}: #{e.message}" if Fast.debugging
+        end
+      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

data/lib/fast/shortcut.rb

@@ -12,14 +12,13 @@ module Fast
       ENV['HOME'],
       ENV['FAST_FILE_DIR'],
       File.join(File.dirname(__FILE__), '..', '..')
-    ].compact.map(&File.method(:expand_path)).uniq.freeze
+    ].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
 
@@ -39,7 +38,20 @@ module Fast
 
     # 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
 
@@ -78,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