ffast 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95125c92ee4201a508f422f041be2a63aebe3a92a19ca303d85b1be98ab6f1e0
-  data.tar.gz: 137a7d81790b9f51aaeea271d4d803b6b33a158f7f4b9f4c8a007a23131e6f05
+  metadata.gz: ebcc19357d7845b5494ede74a18103b84164bbf9e2de41bf3acb1e4010bdc601
+  data.tar.gz: 2bbe9b055db2b8bcc6a855addbf41a642f2c7c74f7cfe015a7e53802b1147113
 SHA512:
-  metadata.gz: 9b1cb25bf21ef812530856cd778b8d875df7498bc9aaa6576c215964c75dc189131f8fdb539b18eec54b8c44fc3033099b74d457135f77feeff6d5f1ebb34405
-  data.tar.gz: 256b3549dd55c412ad1a5d2d84b7d284f4fb94f10096f56a02391ae4e67f4e40894ad1816ab997f7dd08b99b36aa90b9eb68ce3101fa8bba0fb0ba7185329761
+  metadata.gz: fae498867cea1a193d25b2d10f5c4b21c34ef0f70ac76b83c6db39c7966238ae2f20eb0a537f2036ead6177de36542fa08a98d7789a0724e79a7cb358f860e46
+  data.tar.gz: df003c3585970cd06cb82b639ab890d311ae25325b2361cae05d54ef594d0cb0f3043e017b69368fc15495bcc3a20ccb84f276901159542b241d816c7600e7ff

data/lib/fast/node.rb

@@ -70,13 +70,11 @@ module Fast
     end
 
     def updated(type = nil, children = nil, properties = nil)
-      updated_node = self.class.new(
+      self.class.new(
         type || self.type,
         children || self.children,
         { location: properties&.fetch(:location, loc) || loc }
       )
-      updated_node.send(:assign_parents!)
-      updated_node
     end
 
     def ==(other)
@@ -159,7 +157,6 @@ module Fast
     def assign_parents!
       each_child_node do |child|
         self.class.set_parent(child, self)
-        child.send(:assign_parents!) if child.respond_to?(:assign_parents!, true)
       end
     end
 

data/lib/fast/prism_adapter.rb

@@ -87,6 +87,12 @@ module Fast
         statements.is_a?(Node) ? statements : build_node(:begin, statements, node, source, buffer_name)
       when Prism::StatementsNode
         adapt_statements(node, source, buffer_name)
+      when Prism::AliasMethodNode, Prism::AliasGlobalVariableNode
+        build_node(:alias, [adapt(node.new_name, source, buffer_name), adapt(node.old_name, source, buffer_name)], node, source, buffer_name)
+      when Prism::DefinedNode
+        build_node(:defined?, [adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::UndefNode
+        build_node(:undef, node.names.map { |name| adapt(name, source, buffer_name) }, 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
@@ -125,12 +131,31 @@ module Fast
         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::ReturnNode
+        build_node(:return, node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) }, node, source, buffer_name)
+      when Prism::NextNode
+        build_node(:next, node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) }, node, source, buffer_name)
+      when Prism::BreakNode
+        build_node(:break, node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) }, node, source, buffer_name)
+      when Prism::YieldNode
+        build_node(:yield, node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) }, node, source, buffer_name)
+      when Prism::SuperNode
+        build_node(:super, node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) }, node, source, buffer_name)
+      when Prism::ForwardingSuperNode
+        build_node(:zsuper, [], node, source, buffer_name)
+      when Prism::SplatNode
+        build_node(:splat, [adapt(node.expression, source, buffer_name)], node, source, buffer_name)
+      when Prism::AssocSplatNode
+        build_node(:kwsplat, [adapt(node.value, 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::ConstantPathWriteNode
+        build_node(:casgn, [adapt(node.target, source, buffer_name), nil, 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
@@ -143,6 +168,10 @@ module Fast
         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::RegularExpressionNode
+        build_node(:regexp, [build_node(:str, [node.unescaped], node, source, buffer_name), build_node(:regopt, regexp_options(node), node, source, buffer_name)], node, source, buffer_name)
+      when Prism::InterpolatedRegularExpressionNode
+        build_node(:regexp, node.parts.filter_map { |part| adapt(part, source, buffer_name) } + [build_node(:regopt, regexp_options(node), node, 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
@@ -153,12 +182,30 @@ module Fast
         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::RedoNode
+        build_node(:redo, [], node, source, buffer_name)
+      when Prism::RetryNode
+        build_node(:retry, [], node, source, buffer_name)
+      when Prism::PreExecutionNode
+        build_node(:preexe, [adapt_statements(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::PostExecutionNode
+        build_node(:postexe, [adapt_statements(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::NumberedReferenceReadNode
+        build_node(:nth_ref, [node.number], node, source, buffer_name)
+      when Prism::BackReferenceReadNode
+        build_node(:back_ref, [node.name], node, source, buffer_name)
       when Prism::LocalVariableReadNode
         build_node(:lvar, [node.name], node, source, buffer_name)
+      when Prism::LocalVariableTargetNode
+        build_node(:lvasgn, [node.name], node, source, buffer_name)
       when Prism::InstanceVariableReadNode
         build_node(:ivar, [node.name], node, source, buffer_name)
+      when Prism::GlobalVariableReadNode
+        build_node(:gvar, [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::GlobalVariableWriteNode
+        build_node(:gvasgn, [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
@@ -173,33 +220,52 @@ module Fast
           source,
           buffer_name
         )
+      when Prism::MatchWriteNode
+        build_node(:match_with_lvasgn, [adapt(node.call.receiver, source, buffer_name), adapt(node.call.arguments&.arguments&.first, source, buffer_name)], node, source, buffer_name)
+      when Prism::MatchLastLineNode
+        build_node(:match_current_line, [build_node(:regexp, [build_node(:str, [node.unescaped], node, source, buffer_name), build_node(:regopt, regexp_options(node), node, source, buffer_name)], node, 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::RationalNode
+        build_node(:rational, [node.value], node, source, buffer_name)
+      when Prism::ImaginaryNode
+        build_node(:complex, [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::AndNode
+        build_node(:and, [adapt(node.left, source, buffer_name), adapt(node.right, source, buffer_name)], node, source, buffer_name)
+      when Prism::OrNode
+        build_node(:or, [adapt(node.left, source, buffer_name), adapt(node.right, source, buffer_name)], 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::WhileNode
+        build_node(:while, [adapt(node.predicate, source, buffer_name), adapt(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::UntilNode
+        build_node(:until, [adapt(node.predicate, source, buffer_name), adapt(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::ForNode
+        build_node(:for, [adapt(node.index, source, buffer_name), adapt(node.collection, source, buffer_name), adapt(node.statements, source, buffer_name)], node, source, buffer_name)
+      when Prism::MultiWriteNode
+        mlhs_children = node.lefts.map { |left| adapt(left, source, buffer_name) }
+        mlhs_children << adapt(node.rest, source, buffer_name) if node.rest
+        mlhs_children.concat(node.rights.map { |right| adapt(right, source, buffer_name) }) if node.respond_to?(:rights)
+        build_node(:masgn, [build_node(:mlhs, mlhs_children, node, source, buffer_name), adapt(node.value, 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) })
-        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
+        children << adapt(node.consequent, source, buffer_name) if node.consequent
         build_node(:case, children, node, source, buffer_name)
+      when Prism::HashPatternNode
+        build_node(:hash, node.elements.map { |child| adapt(child, source, buffer_name) }, node, source, buffer_name)
       when Prism::WhenNode
         condition =
           if node.conditions.length == 1
@@ -210,12 +276,29 @@ module Fast
         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::CallOperatorWriteNode
+        operator = node.respond_to?(:binary_operator) ? node.binary_operator : node.operator
+        build_node(:op_asgn, [build_node(:send, [adapt(node.receiver, source, buffer_name), node.read_name], node, source, buffer_name), operator, adapt(node.value, source, buffer_name)], node, source, buffer_name)
+      when Prism::IndexOperatorWriteNode
+        operator = node.respond_to?(:binary_operator) ? node.binary_operator : node.operator
+        build_node(:op_asgn, [build_node(:send, [adapt(node.receiver, source, buffer_name), :[]].concat(node.arguments&.arguments.to_a.map { |arg| adapt(arg, source, buffer_name) }), node, source, buffer_name), operator, adapt(node.value, source, buffer_name)], 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)
+        res = adapt_statements(node.statements, source, buffer_name)
+        if node.respond_to?(:rescue_clause) && node.rescue_clause
+          res = build_node(:rescue, [res].concat(adapt_rescue_clause(node.rescue_clause, source, buffer_name)).concat([adapt(node.else_clause, source, buffer_name)]), node, source, buffer_name)
+        end
+        if node.respond_to?(:ensure_clause) && node.ensure_clause
+          res = build_node(:ensure, [res, adapt(node.ensure_clause, source, buffer_name)], node, source, buffer_name)
+        end
+        res
+      when Prism::RescueNode
+        adapt_rescue_clause(node, source, buffer_name)
+      when Prism::EnsureNode
+        adapt_statements(node.statements, source, buffer_name)
       when Prism::EmbeddedVariableNode
         build_node(:begin, [adapt(node.variable, source, buffer_name)].compact, node, source, buffer_name)
+      when Prism::ImplicitNode
+        adapt(node.value, 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
@@ -223,6 +306,33 @@ module Fast
       end
     end
 
+    def adapt_rescue_clause(node, source, buffer_name)
+      resbodies = []
+      current = node
+      while current && current.is_a?(Prism::RescueNode)
+        exceptions = current.exceptions.map { |e| adapt(e, source, buffer_name) }
+        exceptions = build_node(:array, exceptions, current, source, buffer_name) if exceptions.any?
+        resbodies << build_node(:resbody, [exceptions, adapt(current.reference, source, buffer_name), adapt(current.statements, source, buffer_name)], current, source, buffer_name)
+        current = current.respond_to?(:subsequent) ? current.subsequent : current.consequent
+      end
+      resbodies
+    end
+
+    def adapt_else_clause(node, source, buffer_name)
+      adapt(node&.statements, source, buffer_name)
+    end
+
+    def wrap_begin(node, source, buffer_name)
+      return nil unless node
+
+      res = adapt(node, source, buffer_name)
+      if res.is_a?(Node) && res.type == :begin
+        res
+      else
+        build_node(:begin, [nil, res], node, source, buffer_name)
+      end
+    end
+
     def adapt_statements(node, source, buffer_name)
       return nil unless node
 
@@ -299,8 +409,12 @@ module Fast
       send_node
     end
 
-    def adapt_else_clause(node, source, buffer_name)
-      adapt(node.statements, source, buffer_name)
+    def regexp_options(node)
+      options = []
+      options << :i if node.ignore_case?
+      options << :m if node.multi_line?
+      options << :x if node.extended?
+      options
     end
 
     def parameter_name(node)
@@ -308,8 +422,14 @@ module Fast
     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)
+      parent =
+        if node.parent
+          adapt(node.parent, source, buffer_name)
+        elsif node.delimiter_loc
+          build_node(:cbase, [], nil, source, buffer_name)
+        end
+      name = node.respond_to?(:name) ? node.name : node.child.name
+      build_node(:const, [parent, name], node, source, buffer_name)
     end
 
     def build_node(type, children, prism_node, source, buffer_name)

data/lib/fast/version.rb

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

data/lib/fast.rb

@@ -41,6 +41,12 @@ module Fast
     |
     [\d\w_]+[=\\!\?]?     # method names or numbers
     |
+    :[^(){}\[\]\s;]+      # symbols
+    |
+    \/[^\/ \n]+\/         # regex literals
+    |
+    ;                     # semicolons
+    |
     \(|\)                 # parens `(` and `)` for tuples
     |
     \{|\}                 # curly brackets `{` and `}` for any
@@ -259,6 +265,8 @@ module Fast
     # otherwise it recursively collect possible children nodes
     # @yield node and capture if block given
     def search(pattern, node, *args)
+      return [] if node.nil?
+
       if (match = match?(pattern, node, *args))
         yield node, match if block_given?
         match != true ? [node, match] : [node]
@@ -277,6 +285,8 @@ module Fast
     # Only captures from a search
     # @return [Array<Object>] with all captured elements.
     def capture(pattern, node)
+      return [] if node.nil?
+
       if (match = match?(pattern, node))
         match == true ? node : match
       else
@@ -488,6 +498,8 @@ module Fast
       when '^' then Parent.new(parse)
       when '\\' then FindWithCapture.new(parse)
       when /^%\d/ then FindFromArgument.new(token[1..])
+      when ';'
+        raise SyntaxError, "Semicolons are not allowed in patterns: #{token}"
       when nil then nil
       else Find.new(token)
       end
@@ -559,14 +571,16 @@ module Fast
           end
         end
       else
-        node == expression
+        compare_symbol_or_head(expression, node)
       end
     end
 
     def compare_symbol_or_head(expression, node)
+      return true if node.nil? && (expression.nil? || expression == :nil)
+
       case node
       when ->(candidate) { Fast.ast_node?(candidate) }
-        node.type == expression.to_sym
+        node.type == expression&.to_sym
       when String
         node == expression.to_s
       when TrueClass
@@ -614,6 +628,8 @@ module Fast
       case token
       when /^\d+\.\d*/ then token.to_f
       when /^\d+/ then token.to_i
+      when /^:/ then token[1..].to_sym
+      when /^\/.*\/$/ then Regexp.new(token[1..-2])
       else token.to_sym
       end
     end
@@ -830,7 +846,7 @@ module Fast
     def initialize(pattern, ast, *args)
       @ast = ast
       @expression = if pattern.is_a?(String)
-                      Fast.expression(pattern)
+                      Array(Fast.expression(pattern))
                     else
                       [*pattern].map(&Find.method(:new))
                     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffast
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 2026-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderay
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -245,7 +259,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".agents/fast-pattern-expert/SKILL.md"
-- CODE_OF_CONDUCT.md
 - Fastfile
 - LICENSE.txt
 - README.md
@@ -254,7 +267,6 @@ files:
 - bin/fast-experiment
 - bin/fast-mcp
 - bin/setup
-- fast.gemspec
 - lib/fast.rb
 - lib/fast/cli.rb
 - lib/fast/experiment.rb

data/CODE_OF_CONDUCT.md

@@ -1,74 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at jonatas.paganini@toptal.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

data/fast.gemspec

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'fast/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'ffast'
-  spec.version       = Fast::VERSION
-  spec.required_ruby_version = '>= 2.6'
-  spec.authors       = ['Jônatas Davi Paganini']
-  spec.email         = ['jonatasdp@gmail.com']
-  spec.homepage      = 'https://jonatas.github.io/fast/'
-
-  spec.summary       = 'FAST: Find by AST.'
-  spec.description   = 'Allow you to search for code using node pattern syntax.'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|experiments|examples|features|docs|assets|stylesheets|site)/}) ||
-      f.match(%r{^(\.git|\.github|\.travis|\.sourcelevel|\.rubocop|\.projections|\.rspec|Gemfile|Rakefile|Guardfile|mkdocs|requirements-docs|TODO|ideia_blog_post)})
-  end
-
-  spec.post_install_message = <<~THANKS
-
-    ==========================================================
-    Yay! Thanks for installing
-
-       ___       __  ___
-      |__   /\  /__`  |
-      |    /~~\ .__/  |
-
-    To interactive learn about the gem in the terminal use:
-
-    fast .intro
-
-    More docs at: https://jonatas.github.io/fast/
-    ==========================================================
-
-  THANKS
-
-  spec.bindir        = 'bin'
-  spec.executables   = %w[fast fast-experiment fast-mcp]
-  spec.require_paths = %w[lib]
-
-  spec.add_dependency 'coderay'
-  spec.add_dependency 'parallel'
-  spec.add_dependency 'pg_query'
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'git'
-  spec.add_development_dependency 'guard'
-  spec.add_development_dependency 'guard-livereload'
-  spec.add_development_dependency 'guard-rspec'
-  spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rspec-its'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'rubocop-performance'
-  spec.add_development_dependency 'rubocop-rspec'
-  spec.add_development_dependency 'simplecov'
-end