ffast 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da30bc7abc983e2ac54c1c4d1f454878d75dce0dd285a0e245d6ed54d73e4040
-  data.tar.gz: f286ce93d5ce2970d1c3a528d423bf8b8ed9239140f798f895a67e0aa1b8e2d2
+  metadata.gz: 4b5b5e27292bfe589236ccf40952b5da73f4dfc4b35df85220d9beebae7c725e
+  data.tar.gz: 6c4466b554e164c447cfb02760c5b6cd262c0f904f7ea8c35897288efa4668ec
 SHA512:
-  metadata.gz: 83c218849cd4a9184b34f9d760d537cae650fe8a96428aa83fdeff12ed6afc57129fff3ce4a0c6d6924225e178f80c114afb021e19ca41bc2677c85b0668ee99
-  data.tar.gz: 6d4499e8a11398c3f9bc8a04adcd5efd65ef1b385c9bc37370edc31f9375b8d844e8ed61981e33831b2b83961edd4245059a38167c2f7a5ffbc52dd49acb9fff
+  metadata.gz: 0f8ccd9bcd621b69847fd1092b0fa08cada32258a2ec1f6b04654744c8930718628955698673577e4431a6fe6146da744bcb6aafdada442aa08bfe8e5ba32780
+  data.tar.gz: 263b032df9ed1ea5b8d7cd71e1bd613dc781c53fc1dd10cb8bedbe526d904543e1331bb43f345679954e7ebc404b0bdfb5f965dffd35b74c454038ba7ae0fb31

data/.agents/fast-pattern-expert/SKILL.md

@@ -0,0 +1,71 @@
+# Skill: Fast Pattern Expert
+
+You are an expert in constructing and translating natural language queries into `Fast` AST patterns for Ruby.
+
+## Core Expertise
+- Translating structural descriptions of Ruby code into S-expression based AST patterns.
+- Understanding the Ruby AST (Prism/Parser based).
+- Navigating and searching codebases semantically using `Fast`.
+
+## Syntax Reference
+- `(node_type ...)` : Search for a node of a specific type.
+- `_` : Matches any non-nil node/value.
+- `nil` : Matches exactly `nil`.
+- `...` : When last in a list, matches zero or more remaining children. Elsewhere, matches a node with children.
+- `^` : Navigate to the parent node.
+- `$` : Capture the matched node or value.
+- `{type1 type2}` : Union (OR) - matches if any internal expression matches.
+- `[expr1 expr2]` : Intersection (AND) - matches only if all internal expressions match.
+- `!expr` : Negation (NOT) - matches if the expression does not match.
+- `?expr` : Maybe - matches if the node is nil or matches the expression.
+- `\1`, `\2` : Backreference to previous captures.
+- `#custom_method` : Call a custom Ruby method for validation.
+- `.instance_method?` : Call an instance method on the node for validation (e.g., `.odd?`).
+
+## Common Ruby AST Nodes
+- `(def name (args) body)` : Method definition.
+- `(defs receiver name (args) body)` : Singleton method definition.
+- `(send receiver method_name args...)` : Method call.
+- `(class name superclass body)` : Class definition.
+- `(module name body)` : Module definition.
+- `(const scope name)` : Constant reference (scope is nil for top-level).
+- `(casgn scope name value)` : Constant assignment.
+- `(lvar name)` : Local variable read.
+- `(lvasgn name value)` : Local variable assignment.
+- `(ivar name)` : Instance variable read.
+- `(ivasgn name value)` : Instance variable assignment.
+- `(hash (pair key value)...)` : Hash literal.
+- `(array elements...)` : Array literal.
+
+## Translation Examples
+
+### Methods
+- "Find all methods named 'process'" -> `(def process)`
+- "Find methods with at least 3 arguments" -> `(def _ (args _ _ _ ...))`
+- "Find singleton methods (self.method)" -> `(defs ...)`
+- "Find methods that call 'super'" -> `(def _ _ (send nil :super ...))`
+
+### Classes & Modules
+- "Find classes inheriting from ApplicationController" -> `(class _ (const nil ApplicationController))`
+- "Find classes defined inside the 'User' namespace" -> `(class (const (const nil User) _) ...)`
+- "Find modules that include 'Enumerable'" -> `(module _ (begin < (send nil include (const nil Enumerable)) ...))`
+
+### Method Calls
+- "Find all calls to 'User.find'" -> `(send (const nil User) find ...)`
+- "Find calls to 'where' with a hash argument" -> `(send _ where (hash ...))`
+- "Find calls to 'exit' or 'abort'" -> `(send nil {exit abort} ...)`
+
+### Variables & Constants
+- "Find where the 'DEBUG' constant is assigned" -> `(casgn nil DEBUG)`
+- "Find all uses of instance variable '@user'" -> `(ivar @user)`
+- "Find assignments to '@user'" -> `(ivasgn @user)`
+
+## Strategy for Complex Queries
+1. **Identify the anchor node**: What is the primary structure? (e.g., a method definition, a specific call).
+2. **Describe children**: What must be true about its arguments or body?
+3. **Use Union/Intersection**: Combine multiple constraints using `{}` or `[]`.
+4. **Capture if needed**: Use `$` if you only want a specific part of the match.
+5. **Validate**: Always use `validate_fast_pattern` if available to check syntax.
+
+## AST Triage
+If you are unsure of the AST structure for a piece of code, use `Fast.ast("your code snippet")` or `Fast.ast_from_file` to see the s-expression representation. This is the most reliable way to build a pattern.

data/Fastfile

@@ -15,7 +15,7 @@ version_file = Dir['lib/*/version.rb'].first
 Fast.shortcut(:version, '(casgn nil VERSION (str _))', version_file)
 
 # Show all classes that inherits Fast::Find
-Fast.shortcut(:finders, '(class ... (const nil Find)', 'lib')
+Fast.shortcut(:finders, '(class ... (const nil Find))', 'lib')
 
 # You can run shortcuts appending a dot to the shortcut.
 #   $ fast .version
@@ -23,13 +23,13 @@ Fast.shortcut(:finders, '(class ... (const nil Find)', 'lib')
 #   VERSION = '0.1.2'
 
 # Simple shortcut that I used often to show how the expression parser works
-Fast.shortcut(:parser, '(class (const nil ExpressionParser)', 'lib/fast.rb')
-Fast.shortcut(:sql_parser, '(def parse', 'lib/fast/sql.rb')
+Fast.shortcut(:parser, '(class (const nil ExpressionParser))', 'lib/fast.rb')
+Fast.shortcut(:sql_parser, '(def parse ...)', 'lib/fast/sql.rb')
 
 # Use `fast .bump_version` to rewrite the version file
 Fast.shortcut :bump_version do
   new_version = nil
-  rewrite_file('(casgn nil VERSION (str _)', version_file) do |node|
+  rewrite_file('(casgn nil VERSION (str _))', version_file) do |node|
     target = node.children.last.loc.expression
     pieces = target.source.split('.').map(&:to_i)
     pieces.reverse.each_with_index do |fragment, i|

data/README.md

@@ -12,20 +12,6 @@ the code was written without an AST.
 
 Check out the official documentation: https://jonatas.github.io/fast.
 
-## Documentation locally
-
-The documentation site is built with MkDocs Material and a few Markdown
-extensions. To run it locally:
-
-```bash
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install -r requirements-docs.txt
-mkdocs serve
-```
-
-Then open `http://127.0.0.1:8000`.
-
 ## Token Syntax for `find` in AST
 
 The current version of Fast covers the following token elements:
@@ -694,6 +680,20 @@ code("a = 1") # => s(:lvasgn, s(:int, 1))
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+## Documentation locally
+
+The documentation site is built with MkDocs Material and a few Markdown
+extensions. To run it locally:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install -r requirements-docs.txt
+mkdocs serve
+```
+
+Then open `http://127.0.0.1:8000`.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/jonatas/fast. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/ideia_blog_post.md

@@ -0,0 +1,36 @@
+# Empowering LLM Agents with Natural Language to Fast Patterns
+
+Today I'm excited to announce a significant set of improvements to `fast`, specifically designed to bridge the gap between human reasoning (and LLM agents) and the technical precision of Ruby AST searching.
+
+## The Problem: AST Patterns are Hard
+
+Searching through code using AST patterns is incredibly powerful, but constructing the right S-expression can be daunting. Whether you're a human or an AI agent, getting the syntax just right—especially for complex queries—often involves a lot of trial and error.
+
+## The Solution: NL-to-Fast Translation
+
+We've introduced three new tools to solve this:
+
+1.  **The `fast-pattern-expert` Skill**: A specialized Gemini CLI skill that provides deep guidance, syntax references, and few-shot examples for translating structural descriptions of Ruby code into valid `Fast` patterns.
+2.  **`validate_fast_pattern` MCP Tool**: A new tool for our Model Context Protocol (MCP) server that allows agents to verify their generated patterns before executing them.
+3.  **`--validate-pattern` CLI Flag**: A quick way for humans to check if their pattern syntax is correct, checking for balanced nesting and valid token types.
+
+### Example in Action:
+**Query:** "Find all classes that inherit from `BaseService` and have a `call` method."
+**Pattern:** `[(class _ (const nil BaseService)) (def call)]`
+
+## Robustness and Precision
+
+We've also beefed up the core of `fast`:
+- **Stricter Validation**: The `ExpressionParser` now tracks nesting levels and unconsumed tokens, providing helpful error messages instead of silently failing or returning partial matches.
+- **Improved `...` Matcher**: The `...` literal now acts as a "rest-of-children" matcher when used at the end of a pattern, making it much easier to match methods with any number of arguments.
+- **Graceful Degradation**: Multi-file scans (`.scan`) now degrade gracefully if a single file fails to parse, ensuring your reconnaissance isn't aborted by one unsupported syntax node.
+
+## A Safer Release Workflow
+
+On the operational side, I'm moving our gem release process to **GitHub Actions**. By releasing from a clean CI sandbox instead of my local machine, we ensure a much higher level of security and reproducibility. This move minimizes the risk of local environment contamination and provides a transparent, auditable path from source to RubyGems.
+
+## Release 0.2.4
+
+To celebrate these features, we are releasing version `0.2.4` today!
+
+Happy searching!

data/lib/fast/cli.rb

@@ -12,6 +12,12 @@ require 'ostruct'
 # It defines #report and #highlight functions that can be used to pretty print
 # code and results from the search.
 module Fast
+  module SymbolExtension
+    def loc
+      OpenStruct.new(expression: OpenStruct.new(line: 0))
+    end
+  end
+
   module_function
 
   # Highligh some source code based on the node.
@@ -20,19 +26,19 @@ module Fast
   # @param colorize [Boolean] skips `CodeRay` processing when false.
   # @param level [Integer] defines the max depth to print the AST.
   def highlight(node, show_sexp: false, colorize: true, sql: false, level: nil)
-      output =
-        if node.respond_to?(:loc) && !show_sexp
-          if level
-            Fast.fold_source(node, level: level)
-          else
-            wrap_source_range(node).source
-          end
-        elsif show_sexp && level && Fast.ast_node?(node)
-          Fast.fold_ast(node, level: level).to_s
-        elsif show_sexp
-          node.to_s
+    output =
+      if node.respond_to?(:loc) && !show_sexp
+        if level
+          Fast.fold_source(node, level: level)
         else
-          node
+          wrap_source_range(node).source
+        end
+      elsif show_sexp && level && Fast.ast_node?(node)
+        Fast.fold_ast(node, level: level).to_s
+      elsif show_sexp
+        node.to_s
+      else
+        node.to_s
       end
     return output unless colorize
 
@@ -78,6 +84,9 @@ module Fast
   #   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, level: nil) # rubocop:disable Metrics/ParameterLists
     if file
+      if result.is_a?(Symbol) && !result.respond_to?(:loc)
+        result.extend(SymbolExtension)
+      end
       line = result.loc.expression.line if Fast.ast_node?(result) && result.respond_to?(:loc)
       if show_link
         puts(result.link)
@@ -166,6 +175,16 @@ module Fast
           @from_code = true
         end
 
+        opts.on('--validate-pattern PATTERN', 'Validate a node pattern') do |pattern|
+          begin
+            Fast.expression(pattern)
+            puts "Pattern is valid."
+          rescue StandardError => e
+            puts "Invalid pattern: #{e.message}"
+          end
+          exit
+        end
+
         opts.on_tail('--version', 'Show version') do
           puts Fast::VERSION
           exit

data/lib/fast/mcp_server.rb

@@ -10,6 +10,17 @@ module Fast
   # Implements the Model Context Protocol (MCP) server over STDIO.
   class McpServer
     TOOLS = [
+      {
+        name: 'validate_fast_pattern',
+        description: 'Validate a Fast AST pattern. Returns true if valid, or a specific syntax error message if invalid.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Fast AST pattern to validate.' }
+          },
+          required: ['pattern']
+        }
+      },
       {
         name: 'search_ruby_ast',
         description: 'Search Ruby files using a Fast AST pattern. Returns file, line range, and source. Use show_ast=true only when you need the s-expression.',
@@ -146,8 +157,14 @@ module Fast
       args      = params['arguments'] || {}
       show_ast  = args['show_ast'] || false
 
+      if args['pattern'] && !args['pattern'].start_with?('(', '{', '[') && !args['pattern'].match?(/^[a-z_]+$/)
+        raise "Invalid Fast AST pattern: '#{args['pattern']}'. Did you mean to use an s-expression like '(#{args['pattern']})'?"
+      end
+
       result =
         case tool_name
+        when 'validate_fast_pattern'
+          execute_validate_pattern(args['pattern'])
         when 'search_ruby_ast'
           execute_search(args['pattern'], args['paths'], show_ast: show_ast)
         when 'ruby_method_source'
@@ -170,6 +187,13 @@ module Fast
       write_error(id, -32603, 'Tool execution failed', e.message)
     end
 
+    def execute_validate_pattern(pattern)
+      Fast.expression(pattern)
+      { valid: true }
+    rescue StandardError => e
+      { valid: false, error: e.message }
+    end
+
     def execute_search(pattern, paths, show_ast: false)
       results = []
       on_result = ->(file, matches) do

data/lib/fast/prism_adapter.rb

@@ -135,8 +135,12 @@ module Fast
         build_node(:sym, [node.unescaped], node, source, buffer_name)
       when Prism::StringNode
         build_node(:str, [node.unescaped], node, source, buffer_name)
+      when Prism::XStringNode
+        build_node(:xstr, [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::InterpolatedXStringNode
+        build_node(:dxstr, 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
@@ -183,6 +187,8 @@ module Fast
         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::RescueModifierNode
+        build_node(:rescue, [adapt(node.expression, source, buffer_name), build_node(:resbody, [nil, nil, adapt(node.rescue_expression, source, buffer_name)], node, source, buffer_name), nil], 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) })
@@ -231,10 +237,10 @@ module Fast
       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.concat(node.requireds.map { |child| adapt_required_parameter(child, source, buffer_name) }) if node.respond_to?(:requireds)
+      children.concat(node.optionals.map { |child| build_node(:optarg, [parameter_name(child), 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.posts.map { |child| adapt_required_parameter(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
@@ -248,14 +254,25 @@ module Fast
       adapt_parameters(params, source, buffer_name)
     end
 
+    def adapt_required_parameter(child, source, buffer_name)
+      if child.is_a?(Prism::MultiTargetNode)
+        mlhs_children = child.lefts.map { |c| adapt_required_parameter(c, source, buffer_name) }
+        mlhs_children << build_node(:restarg, [parameter_name(child.rest)], child.rest, source, buffer_name) if child.respond_to?(:rest) && child.rest
+        mlhs_children.concat(child.rights.map { |c| adapt_required_parameter(c, source, buffer_name) }) if child.respond_to?(:rights)
+        build_node(:mlhs, mlhs_children, child, source, buffer_name)
+      else
+        build_node(:arg, [parameter_name(child)], child, source, buffer_name)
+      end
+    end
+
     def adapt_keyword_parameter(node, source, buffer_name)
       case node
       when Prism::RequiredKeywordParameterNode
-        build_node(:kwarg, [node.name], node, source, buffer_name)
+        build_node(:kwarg, [parameter_name(node)], node, source, buffer_name)
       when Prism::OptionalKeywordParameterNode
-        build_node(:kwoptarg, [node.name, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+        build_node(:kwoptarg, [parameter_name(node), adapt(node.value, source, buffer_name)], node, source, buffer_name)
       else
-        build_node(:arg, [node.name], node, source, buffer_name)
+        build_node(:arg, [parameter_name(node)], node, source, buffer_name)
       end
     end
 

data/lib/fast/scan.rb

@@ -25,10 +25,14 @@ module Fast
     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?
+        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]
+          memo[classify(file, entries)] << [file, entries]
+        rescue StandardError => e
+          warn "Error scanning #{file}: #{e.message}" if Fast.debugging
+        end
       end
 
       print_grouped(grouped)

data/lib/fast/summary.rb

@@ -21,7 +21,12 @@ module Fast
         if unsupported_template?
           nil
         elsif code_or_ast.is_a?(String)
-          Fast.parse_ruby(code_or_ast, buffer_name: file || '(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

data/lib/fast/version.rb

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

data/lib/fast.rb

@@ -220,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 `$`
@@ -275,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
@@ -444,6 +460,7 @@ module Fast
     # @param expression [String]
     def initialize(expression)
       @tokens = expression.scan TOKENIZER
+      @nesting = []
     end
 
     # rubocop:disable Metrics/CyclomaticComplexity
@@ -451,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
@@ -477,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
@@ -503,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
@@ -798,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffast
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-30 00:00:00.000000000 Z
+date: 2026-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderay
@@ -243,6 +243,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".agents/fast-pattern-expert/SKILL.md"
 - ".github/workflows/release.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
@@ -265,6 +266,7 @@ files:
 - bin/fast-mcp
 - bin/setup
 - fast.gemspec
+- ideia_blog_post.md
 - lib/fast.rb
 - lib/fast/cli.rb
 - lib/fast/experiment.rb