ffast 0.2.2 → 0.2.4

data/lib/fast.rb

@@ -1,28 +1,17 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require 'astrolabe/builder'
-require_relative 'fast/rewriter'
-
-# suppress output to avoid parser gem warnings'
-def suppress_output
-  original_stdout = $stdout.clone
-  original_stderr = $stderr.clone
-  $stderr.reopen File.new('/dev/null', 'w')
-  $stdout.reopen File.new('/dev/null', 'w')
-  yield
-ensure
-  $stdout.reopen original_stdout
-  $stderr.reopen original_stderr
-end
 
-suppress_output do
-  require 'parser'
-  require 'parser/current'
-end
+require_relative 'fast/source'
+require_relative 'fast/node'
+require_relative 'fast/rewriter'
 
 # Fast is a tool to help you search in the code through the Abstract Syntax Tree
 module Fast
+  NODE_PARENTS = ObjectSpace::WeakMap.new
+
+  class SyntaxError < StandardError; end
+
   # Literals are shortcuts allowed inside {ExpressionParser}
   LITERAL = {
     '...' => ->(node) { node&.children&.any? },
@@ -67,83 +56,95 @@ module Fast
     %\d                   # bind extra arguments to the expression
   /x.freeze
 
-  # Set some convention methods from file.
-  class Node < Astrolabe::Node
-    # @return [String] with path of the file or simply buffer name.
-    def buffer_name
-      expression.source_buffer.name
+  class << self
+    def ast_node?(node)
+      node.respond_to?(:type) && node.respond_to?(:children)
     end
 
-    # @return [Parser::Source::Range] from the expression
-    def expression
-      location.expression
+    def prism_ast(content, buffer_name: '(string)')
+      require_relative 'fast/prism_adapter'
+      result = Fast::PrismAdapter.parse(content, buffer_name: buffer_name)
+      return result if result
+
+      prism_errors = Prism.parse(content).errors
+      message = prism_errors.map(&:message).uniq.join("\n")
+      raise SyntaxError, message
     end
 
-    # @return [String] with the content of the #expression
-    def source
-      expression.source
+    def parse_ruby(content, buffer_name: '(string)')
+      prism_ast(content, buffer_name: buffer_name)
     end
 
-    # @return [Boolean] true if a file exists with the #buffer_name
-    def from_file?
-      File.exist?(buffer_name)
+    def parser_ast(content, buffer_name: '(string)')
+      prism_ast(content, buffer_name: buffer_name)
     end
 
-    # @return [Array<String>] with authors from the current expression range
-    def blame_authors
-      `git blame -L #{expression.first_line},#{expression.last_line} #{buffer_name}`.lines.map do |line|
-        line.split('(')[1].split(/\d+/).first.strip
-      end
+    def parser_ast_from_file(file)
+      @parser_cache ||= {}
+      @parser_cache[file] ||=
+        begin
+          method =
+            if file.end_with?('.sql')
+              require_relative 'fast/sql' unless respond_to?(:parse_sql)
+              :parse_sql
+            else
+              :parser_ast
+            end
+          Fast.public_send(method, IO.read(file), buffer_name: file)
+        end
     end
 
-    # @return [String] with the first element from #blame_authors
-    def author
-      blame_authors.first
+    def parse_file(file)
+      return parser_ast_from_file(file) if file.end_with?('.sql')
+
+      @cache ||= {}
+      @cache[file] ||=
+        begin
+          parse_ruby(IO.read(file), buffer_name: file)
+        end
     end
 
-    # Search recursively into a node and its children using a pattern.
-    # @param [String] pattern
-    # @param [Array] *args extra arguments to interpolate in the pattern.
-    # @return [Array<Fast::Node>>] with files and results
-    def search(pattern, *args)
-      Fast.search(pattern, self, *args)
+    def summary(code_or_ast, file: nil, command_name: '.summary', level: nil)
+      require_relative 'fast/summary'
+      Summary.new(code_or_ast, file: file, command_name: command_name, level: level)
     end
 
-    # Captures elements from search recursively
-    # @param [String] pattern
-    # @param [Array] *args extra arguments to interpolate in the pattern.
-    # @return [Array<Fast::Node>>] with files and results
-    def capture(pattern, *args)
-      Fast.capture(pattern, self, *args)
+    def scan(locations, command_name: '.scan', level: nil)
+      require_relative 'fast/scan'
+      Scan.new(locations, command_name: command_name, level: level)
     end
-  end
 
-  # Custom builder allow us to set a buffer name for each Node
-  class Builder < Astrolabe::Builder
-    attr_writer :buffer_name
-    # Generates {Node} from the given information.
-    #
-    # @return [Node] the generated node
-    def n(type, children, source_map)
-      Node.new(type, children, location: source_map, buffer_name: @buffer_name)
+    def parser_class
+      raise NoMethodError, 'Fast.parser_class was removed; Fast now parses Ruby with Prism'
+    end
+
+    def parser_require_path
+      raise NoMethodError, 'Fast.parser_require_path was removed; Fast now parses Ruby with Prism'
+    end
+
+    def parser_const_name
+      raise NoMethodError, 'Fast.parser_const_name was removed; Fast now parses Ruby with Prism'
+    end
+
+    def parser_version_supported?(const_name)
+      raise NoMethodError, "Fast.parser_version_supported?(#{const_name.inspect}) was removed; Fast now parses Ruby with Prism"
     end
-  end
 
-  class << self
     # @return [Fast::Node] from the parsed content
     # @example
     #   Fast.ast("1") # => s(:int, 1)
     #   Fast.ast("a.b") # => s(:send, s(:send, nil, :a), :b)
     def ast(content, buffer_name: '(string)')
-      buffer = Parser::Source::Buffer.new(buffer_name)
-      buffer.source = content
-      Parser::CurrentRuby.new(builder_for(buffer_name)).parse(buffer)
+      parse_ruby(content, buffer_name: buffer_name)
+    end
+
+    def validate_ruby!(content, buffer_name: '(string)')
+      prism_ast(content, buffer_name: buffer_name)
+      true
     end
 
     def builder_for(buffer_name)
-      builder = Builder.new
-      builder.buffer_name = buffer_name
-      builder
+      raise NoMethodError, "Fast.builder_for(#{buffer_name.inspect}) was removed; Fast now parses Ruby with Prism"
     end
 
     # @return [Fast::Node] parsed from file content
@@ -152,18 +153,7 @@ module Fast
     # @example
     #   Fast.ast_from_file("example.rb") # => s(...)
     def ast_from_file(file)
-      @cache ||= {}
-      @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
+      parse_file(file)
     end
 
     # Verify if a given AST matches with a specific pattern
@@ -230,12 +220,24 @@ module Fast
     # @return [Hash[String, Array]] with files and results
     def group_results(group_files, locations, parallel: true)
       files = ruby_files_from(*locations)
-      if parallel
-        require 'parallel' unless defined?(Parallel)
-        Parallel.map(files, &group_files)
-      else
-        files.map(&group_files)
-      end.compact.inject(&:merge!)
+      results =
+        if parallel
+          require 'parallel' unless defined?(Parallel)
+          Parallel.map(files) do |file|
+            group_files.call(file)
+          rescue StandardError => e
+            warn "Error processing #{file}: #{e.message}" if Fast.debugging
+            nil
+          end
+        else
+          files.map do |file|
+            group_files.call(file)
+          rescue StandardError => e
+            warn "Error processing #{file}: #{e.message}" if Fast.debugging
+            nil
+          end
+        end
+      results.compact.inject(&:merge!) || {}
     end
 
     # Capture elements from searches in files. Keep in mind you need to use `$`
@@ -285,7 +287,11 @@ module Fast
     end
 
     def expression(string)
-      ExpressionParser.new(string).parse
+      parser = ExpressionParser.new(string)
+      res = parser.parse
+      raise SyntaxError, parser.error_message if parser.tokens_left?
+
+      res
     end
 
     attr_accessor :debugging
@@ -330,6 +336,73 @@ module Fast
       files.reject(&dir_filter)
     end
 
+    # Folds the AST to a maximum depth, replacing deeper branches with `...`
+    # @param node [Fast::Node]
+    # @param level [Integer] maximum depth to explore
+    # @param current_level [Integer] internal tracker for depth
+    # @return [Fast::Node] the folded AST
+    def fold_ast(node, level: nil, current_level: 1)
+      return node unless ast_node?(node) && node.respond_to?(:updated)
+      return node if level.nil?
+
+      if current_level >= level
+        if node.children.any?
+          node.updated(nil, [:'...'])
+        else
+          node
+        end
+      else
+        new_children = node.children.map { |c| fold_ast(c, level: level, current_level: current_level + 1) }
+        node.updated(nil, new_children)
+      end
+    end
+
+    # Folds ruby source code to a maximum depth, replacing deep block bodies with `# ...`
+    # @param node [Fast::Node]
+    # @param level [Integer] maximum depth to explore
+    # @return [String] the folded source representation
+    def fold_source(node, level: 1)
+      return node if node.is_a?(String)
+      return node.loc.expression.source rescue node.to_s unless ast_node?(node) && node.respond_to?(:loc)
+
+      source = node.loc.expression.source.dup
+      root_begin = node.loc.expression.begin_pos
+
+      regions = []
+
+      walker = ->(n, current_level) do
+        return unless ast_node?(n)
+
+        if current_level >= level
+          body_node = nil
+          case n.type
+          when :class, :module, :def, :defs, :block
+            body_node = n.children.last
+          when :begin
+            body_node = n
+          end
+
+          if body_node && body_node.loc && body_node.loc.respond_to?(:expression) && body_node.loc.expression
+            regions << [
+              body_node.loc.expression.begin_pos - root_begin,
+              body_node.loc.expression.end_pos - root_begin
+            ]
+            return
+          end
+        end
+
+        n.children.each { |c| walker.call(c, current_level + 1) if ast_node?(c) }
+      end
+
+      walker.call(node, 1)
+
+      regions.sort_by { |r| -r[0] }.each do |start_pos, end_pos|
+        source[start_pos...end_pos] = "# ..."
+      end
+
+      source
+    end
+
     # Extracts a node pattern expression from a given node supressing identifiers and primitive types.
     # Useful to index abstract patterns or similar code structure.
     # @see https://jonatas.github.io/fast/similarity_tutorial/
@@ -341,7 +414,7 @@ module Fast
     #   Fast.expression_from(Fast.ast('def name; person.name end')) # => '(def _ (args) (send (send nil _) _))'
     def expression_from(node)
       case node
-      when Parser::AST::Node
+      when ->(candidate) { ast_node?(candidate) }
         children_expression = node.children.map(&method(:expression_from)).join(' ')
         "(#{node.type}#{" #{children_expression}" if node.children.any?})"
       when nil, 'nil'
@@ -387,6 +460,7 @@ module Fast
     # @param expression [String]
     def initialize(expression)
       @tokens = expression.scan TOKENIZER
+      @nesting = []
     end
 
     # rubocop:disable Metrics/CyclomaticComplexity
@@ -394,22 +468,43 @@ module Fast
     # rubocop:disable Metrics/MethodLength
     def parse
       case (token = next_token)
-      when '(' then parse_until_peek(')')
-      when '{' then Any.new(parse_until_peek('}'))
-      when '[' then All.new(parse_until_peek(']'))
+      when '('
+        @nesting << ')'
+        parse_until_peek(')')
+      when '{'
+        @nesting << '}'
+        Any.new(parse_until_peek('}'))
+      when '['
+        @nesting << ']'
+        All.new(parse_until_peek(']'))
+      when ')', '}', ']'
+        raise SyntaxError, "Unexpected token: #{token}"
       when /^"/ then FindString.new(token[1..-2])
       when /^#\w/ then MethodCall.new(token[1..])
       when /^\.\w[\w\d_]+\?/ then InstanceMethodCall.new(token[1..])
       when '$' then Capture.new(parse)
-      when '!' then (@tokens.any? ? Not.new(parse) : Find.new(token))
+      when '!' then (@tokens.any? && !closing_token?(@tokens.first) ? Not.new(parse) : Find.new(token))
       when '?' then Maybe.new(parse)
       when '^' then Parent.new(parse)
       when '\\' then FindWithCapture.new(parse)
       when /^%\d/ then FindFromArgument.new(token[1..])
+      when nil then nil
       else Find.new(token)
       end
     end
 
+    def tokens_left?
+      @tokens.any? || @nesting.any?
+    end
+
+    def error_message
+      if @tokens.any?
+        "Unconsumed tokens after parsing: #{@tokens.join(' ')}"
+      elsif @nesting.any?
+        "Unclosed nesting: expected #{@nesting.reverse.join(', ')}"
+      end
+    end
+
     # rubocop:enable Metrics/CyclomaticComplexity
     # rubocop:enable Metrics/AbcSize
     # rubocop:enable Metrics/MethodLength
@@ -420,10 +515,19 @@ module Fast
       @tokens.shift
     end
 
+    def closing_token?(token)
+      [')', '}', ']'].include?(token)
+    end
+
     def parse_until_peek(token)
       list = []
       list << parse until @tokens.empty? || @tokens.first == token
-      next_token
+      last = next_token
+      if last == token
+        @nesting.pop
+      else
+        raise SyntaxError, "Expected #{token} but got #{last || 'end of string'}"
+      end
       list
     end
   end
@@ -446,8 +550,14 @@ module Fast
       when Find then expression.match?(node)
       when Symbol then compare_symbol_or_head(expression, node)
       when Enumerable
-        expression.each_with_index.all? do |exp, i|
-          match_recursive(exp, i.zero? ? node : node.children[i - 1])
+        if expression.last == :'...' || expression.last.is_a?(Find) && expression.last.token == '...'
+          expression[0...-1].each_with_index.all? do |exp, i|
+            match_recursive(exp, i.zero? ? node : node.children[i - 1])
+          end
+        else
+          expression.each_with_index.all? do |exp, i|
+            match_recursive(exp, i.zero? ? node : node.children[i - 1])
+          end
         end
       else
         node == expression
@@ -456,7 +566,7 @@ module Fast
 
     def compare_symbol_or_head(expression, node)
       case node
-      when Parser::AST::Node
+      when ->(candidate) { Fast.ast_node?(candidate) }
         node.type == expression.to_sym
       when String
         node == expression.to_s
@@ -741,10 +851,17 @@ module Fast
 
     # @return [true] if all children matches with tail
     def match_tail?(tail, child)
-      tail.each_with_index.all? do |token, i|
-        prepare_token(token)
-        token.is_a?(Array) ? match?(token, child[i]) : token.match?(child[i])
-      end && find_captures
+      if tail.last.is_a?(Find) && tail.last.token == '...'
+        tail[0...-1].each_with_index.all? do |token, i|
+          prepare_token(token)
+          token.is_a?(Array) ? match?(token, child[i]) : token.match?(child[i])
+        end && find_captures
+      else
+        tail.each_with_index.all? do |token, i|
+          prepare_token(token)
+          token.is_a?(Array) ? match?(token, child[i]) : token.match?(child[i])
+        end && find_captures
+      end
     end
 
     # Look recursively into @param expression to check if the expression is have

data/mkdocs.yml

@@ -1,7 +1,11 @@
 site_name: Fast
 repo_url: https://github.com/jonatas/fast
 edit_uri: edit/master/docs/
-google_analytics: ['G-YKZDZDNRG2', 'auto']
+
+extra:
+  analytics:
+    provider: google
+    property: G-YKZDZDNRG2
 
 theme:
   name: material
@@ -13,10 +17,15 @@ theme:
 extra_css:
   - stylesheets/custom.css
 
+plugins:
+  - search
+
 markdown_extensions:
   - admonition
-  - codehilite:
-      guess_lang: false
+  - pymdownx.details
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+      alternate_style: true
   - toc:
       permalink: true
 nav:
@@ -27,10 +36,16 @@ nav:
   - Experiments: experiments.md
   - Shortcuts: shortcuts.md
   - Git Integration: git.md
+  - Fast for LLMs and Agents: agents.md
+  - MCP Server Tutorial: mcp_tutorial.md
   - Code Similarity: similarity_tutorial.md
+  - LLM/Agent Feature TODOs: llm_features.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
+  - SQL:
+    - Intro: sql/index.md
+    - Shortcuts: sql/shortcuts.md
+    - About: sql-support.md

data/requirements-docs.txt

@@ -0,0 +1,3 @@
+mkdocs>=1.6,<2.0
+mkdocs-material>=9.5,<10.0
+pymdown-extensions>=10.0,<11.0

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ffast
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Jônatas Davi Paganini
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-17 00:00:00.000000000 Z
+date: 2026-03-31 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: astrolabe
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: coderay
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: parser
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: pg_query
   requirement: !ruby/object:Gem::Requirement
@@ -271,6 +243,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".agents/fast-pattern-expert/SKILL.md"
+- ".github/workflows/release.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".projections.json"
 - ".rspec"
@@ -288,43 +263,28 @@ files:
 - bin/console
 - bin/fast
 - bin/fast-experiment
+- bin/fast-mcp
 - bin/setup
-- docs/command_line.md
-- docs/editors-integration.md
-- docs/experiments.md
-- docs/git.md
-- docs/ideas.md
-- docs/index.md
-- docs/pry-integration.md
-- docs/research.md
-- docs/shortcuts.md
-- docs/similarity_tutorial.md
-- docs/sql-support.md
-- docs/syntax.md
-- docs/videos.md
-- docs/walkthrough.md
-- examples/build_stubbed_and_let_it_be_experiment.rb
-- examples/experimental_replacement.rb
-- examples/find_usage.rb
-- examples/let_it_be_experiment.rb
-- examples/method_complexity.rb
-- examples/search_duplicated.rb
-- examples/similarity_research.rb
-- examples/simple_rewriter.rb
-- experiments/let_it_be_experiment.rb
-- experiments/remove_useless_hook.rb
-- experiments/replace_create_with_build_stubbed.rb
 - fast.gemspec
+- ideia_blog_post.md
 - lib/fast.rb
 - lib/fast/cli.rb
 - lib/fast/experiment.rb
 - lib/fast/git.rb
+- lib/fast/mcp_server.rb
+- lib/fast/node.rb
+- lib/fast/prism_adapter.rb
 - lib/fast/rewriter.rb
+- lib/fast/scan.rb
 - lib/fast/shortcut.rb
+- lib/fast/source.rb
+- lib/fast/source_rewriter.rb
 - lib/fast/sql.rb
 - lib/fast/sql/rewriter.rb
+- lib/fast/summary.rb
 - lib/fast/version.rb
 - mkdocs.yml
+- requirements-docs.txt
 homepage: https://jonatas.github.io/fast/
 licenses:
 - MIT
@@ -360,9 +320,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key:
+rubygems_version: 3.5.22
+signing_key: 
 specification_version: 4
 summary: 'FAST: Find by AST.'
 test_files: []
-...