ffast 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c664b4d8bafbac99cd9814bcdf77e730184c6e9a38a01ab52d21369bc9c52f8d
-  data.tar.gz: 3f761262fc7db1a9ab856fcdab4bfe1580187d882f253f03cd82138b745a43d9
+  metadata.gz: d1ae41b9a66311eb3308fd3ca3f69f5a06943a337f9907d502f1a2ed27342a46
+  data.tar.gz: 80e545ae2769ab27ba39d8338b57c60626ca3f79ec5e73139c12f3cb01dfd5fb
 SHA512:
-  metadata.gz: 742d1f586ede35f47ecdcd27013d9e2082641a7809edc6ea43e1538954a805d9d8aadd2f3c6772161bcad2df6223ba2920a71d745a067e3a6ca91c8ef220c2f4
-  data.tar.gz: 7cb8e4d954d2ecea9e8a5d3f6f94a7b08ecaed80df1b6ee72bcb8e2b0ca58ce1fd20a84166f884fe8d38f4c692ae1da129ec3276a46d3f6a820efde903e830fd
+  metadata.gz: fbcb874fb1c2916d0fa89d687fd9e320f248c8cc64c5193244b8d007b39cffb86b23db2ff7c3134c4d43baba1d4d99b6526831a20b3c630867691d5076ae33bc
+  data.tar.gz: de6c3a1e706f6a3e39791a413584dc227af3ee8810628145b0844d9b4d2ac1f9d7f631c9db859a7cb6d8c7f56313b3f0aff2be4b9868627c31ece3924e79379c

data/Fastfile

@@ -8,6 +8,9 @@
 # Let's say you'd like to show the version that is over the version file
 Fast.shortcut(:version, '(casgn nil VERSION (str _))', 'lib/fast/version.rb')
 
+# Show all classes that inherits Fast::Find
+Fast.shortcut(:finders, '(class ... (const nil Find)', 'lib')
+
 # You can run shortcuts appending a dot to the shortcut.
 #   $ fast .version
 #   # lib/fast/version.rb:4

data/README.md

@@ -421,6 +421,7 @@ The CLI tool takes the following flags
 - Use `--pry` to jump debugging the first result with pry
 - Use `-c` to search from code example
 - Use `-s` to search similar code
+- Use `-p` or `--parallel` to parallelize the search
 
 ### Define your `Fastfile`
 

data/docs/command_line.md

@@ -11,6 +11,7 @@ $ fast '(def match?)' lib/fast.rb
 - Use `--pry` to jump debugging the first result with pry
 - Use `-c` to search from code example
 - Use `-s` to search similar code
+- Use `-p` to or `--parallel` to use multi core search
 
 ## `--pry`
 

data/docs/editors-integration.md

@@ -0,0 +1,46 @@
+# Editors' integration
+
+We don't have any proper integration or official plugins for editors yet.
+
+Here are a few ideas you can use to make your own flow.
+
+## Vim
+
+Split terminal vertically and open fast focused on build the expression.
+
+```vim
+nnoremap <Leader>ff :vsplit \| terminal fast "()" % <Left><Left><Left><Left><Left>
+```
+
+Or you can build a function:
+
+```vim
+function! s:Fast(args)
+  let cmd = ''
+  if !empty(b:ruby_project_root)
+    let cmd .= 'cd ' . b:ruby_project_root . ' && '
+  endif
+
+  let cmd .= 'fast --no-color ' . a:args
+
+  let custom_maker = neomake#utils#MakerFromCommand(cmd)
+  let custom_maker.name = cmd
+  let custom_maker.cwd = b:ruby_project_root
+  let custom_maker.remove_invalid_entries = 0
+  " e.g.:
+  "   # path/to/file.rb:1141
+  "   my_method(
+  "     :boom,
+  "     arg1: 1,
+  "   )
+  " %W# %f:%l -> start a multiline warning when the line matches '# path/file.rb:1234'
+  " %-Z# end multiline warning on the next line that starts with '#'
+  " %C%m continued multiline warning message
+  let custom_maker.errorformat = '%W# %f:%l, %-Z#, %C%m'
+  let enabled_makers = [custom_maker]
+  update | call neomake#Make(0, enabled_makers) | echom "running: " . cmd
+endfunction
+command! -complete=file -nargs=1 Fast call s:Fast(<q-args>)
+```
+
+Check the conversation about vim integration [here](https://github.com/jonatas/fast/pull/16#issuecomment-555115606).

data/docs/shortcuts.md

@@ -0,0 +1,288 @@
+# Shortcuts
+
+Shortcuts are defined on a `Fastfile` inside any ruby project.
+
+!!!info "Use `~/Fastfile`"
+    You can also add one extra in your `$HOME` if you want to have something loaded always.
+
+By default, the command line interface does not load any `Fastfile` if the
+first param is not a shortcut. It should start with `.`.
+
+I'm building several researches and I'll make the examples open here to show
+several interesting cases in action.
+
+## Rails: Show validations from models
+
+If the shortcut does not define a block, it works as a holder for arguments from
+the command line.
+
+Let's say you always use `fast "(send nil {validate validates})" app/models` to
+check validations in the models. You can define a shortcut to hold the args and
+avoid retyping long lines:
+
+```ruby
+# Show validations from app/models
+Fast.shortcut(:validations, "(send nil {validate validates})", "app/models")
+```
+And you can reuse the search with the shortcut starting with a `.`:
+
+```
+fast .validations
+```
+And it will also accept params if you want to filter a specific file:
+
+```
+fast .validations app/models/user.rb
+```
+
+!!! info "Note that you can also use flags in the command line shortcuts"
+
+    Let's say you also want to use `fast --headless` you can add it to the params:
+
+    > Fast.shortcut(:validations, "(send nil {validate validates})", "app/models", "--headless")
+
+## Automated Refactor: Bump version
+
+Let's start with a [real usage](https://github.com/jonatas/fast/blob/master/Fastfile#L20-L34)
+to bump a new version of the gem.
+
+```ruby
+Fast.shortcut :bump_version do
+  rewrite_file('(casgn nil VERSION (str _)', 'lib/fast/version.rb') do |node|
+    target = node.children.last.loc.expression
+    pieces = target.source.split('.').map(&:to_i)
+    pieces.reverse.each_with_index do |fragment, i|
+      if fragment < 9
+        pieces[-(i + 1)] = fragment + 1
+        break
+      else
+        pieces[-(i + 1)] = 0
+      end
+    end
+    replace(target, "'#{pieces.join('.')}'")
+  end
+end
+```
+
+And then the change is done in the `lib/fast/version.rb`:
+
+```diff
+module Fast
+-  VERSION = '0.1.6'
++  VERSION = '0.1.7'
+end
+```
+
+## List Shortcuts
+
+As the interface is very rudimentar, let's build a shortcut to print what
+shortcuts are available. This is a good one to your `$HOME/Fastfile`:
+
+```ruby
+# List all shortcut with comments
+Fast.shortcut :shortcuts do
+  fast_files.each do |file|
+    lines = File.readlines(file).map{|line|line.chomp.gsub(/\s*#/,'').strip}
+    result = capture_file('(send ... shortcut $(sym _', file)
+    result = [result] unless result.is_a?Array
+    result.each do |capture|
+      target = capture.loc.expression
+      puts "fast .#{target.source[1..-1].ljust(30)} # #{lines[target.line-2]}"
+    end
+  end
+end
+```
+
+And using it on `fast` project that loads both `~/Fastfile` and the Fastfile from the project:
+
+```
+fast .version       # Let's say you'd like to show the version that is over the version file
+fast .parser        # Simple shortcut that I used often to show how the expression parser works
+fast .bump_version  # Use `fast .bump_version` to rewrite the version file
+fast .shortcuts     # List all shortcut with comments
+```
+
+## RSpec: Find unused shared contexts
+
+If you build shared contexts often, probably you can forget some left overs.
+
+The objective of the shortcut is find leftovers from shared contexts.
+
+First, the objective is capture all names of the `RSpec.shared_context` or
+ `shared_context` declared in the `spec/support` folder.
+
+```ruby
+Fast.capture_all('(block (send {nil,_} shared_context (str $_)))', Fast.ruby_files_from('spec/support'))
+```
+
+Then, we need to check all the specs and search for `include_context` usages to
+confirm if all defined contexts are being used:
+
+```ruby
+specs = Fast.ruby_files_from('spec').select{|f|f !~ %r{spec/support/}}
+Fast.search_all("(send nil include_context (str #register_usage)", specs)
+```
+
+Note that we created a new reference to `#register_usage` and we need to define the method too:
+
+
+```ruby
+@used = []
+def register_usage context_name
+	@used << context_name
+end
+```
+
+Wrapping up everything in a shortcut:
+
+```ruby
+# Show unused shared contexts
+Fast.shortcut(:unused_shared_contexts) do
+  puts "Checking shared contexts"
+  Kernel.class_eval do
+    @used = []
+    def register_usage context_name
+      @used << context_name
+    end
+    def show_report! defined_contexts
+      unused = defined_contexts.values.flatten - @used
+      if unused.any?
+        puts "Unused shared contexts", unused
+      else
+        puts "Good job! all the #{defined_contexts.size} contexts are used!"
+      end
+    end
+  end
+  specs = ruby_files_from('spec/').select{|f|f !~ %r{spec/support/}}
+  search_all("(send nil include_context (str #register_usage)", specs)
+  defined_contexts = capture_all('(block (send {nil,_} shared_context (str $_)))', ruby_files_from('spec'))
+  Kernel.public_send(:show_report!, defined_contexts)
+end
+```
+
+!!! faq "Why `#register_usage` is defined on the `Kernel`?"
+    Yes! note that the `#register_usage` was forced to be inside `Kernel`
+    because of the `shortcut` block that takes the `Fast` context to be easy
+    to access in the default functions. As I can define multiple shortcuts
+    I don't want to polute my Kernel module with other methods that are not useful.
+
+
+## RSpec: Remove unused let
+
+!!! hint "First shortcut with experiments"
+    If you're not familiar with automated experiments, you can read about it [here](/experiments).
+
+The current scenario is similar in terms of search with the previous one, but more advanced
+because we're going to introduce automated refactoring.
+
+The idea is simple, if it finds a `let` in a RSpec scenario that is not referenced, it tries to experimentally remove the `let` and run the tests:
+
+```ruby
+# Experimental remove `let` that are not referenced in the spec
+Fast.shortcut(:exp_remove_let) do
+  require 'fast/experiment'
+  Kernel.class_eval do
+    file = ARGV.last
+
+    defined_lets = Fast.capture_file('(block (send nil let (sym $_)))', file).uniq
+    @unreferenced= defined_lets.select do |identifier|
+      Fast.search_file("(send nil #{identifier})", file).empty?
+    end
+
+    def unreferenced_let?(identifier)
+      @unreferenced.include? identifier
+    end
+  end
+
+  experiment('RSpec/RemoveUnreferencedLet') do
+    lookup ARGV.last
+    search '(block (send nil let (sym #unreferenced_let?)))'
+    edit { |node| remove(node.loc.expression) }
+    policy { |new_file| system("bundle exec rspec --fail-fast #{new_file}") }
+  end.run
+end
+```
+
+And it will run with a single file from command line:
+
+```
+fast .exp_remove_let spec/my_file_spec.rb
+```
+
+## FactoryBot: Replace `create` with `build_stubbed`
+
+For performance reasons, if we can avoid touching the database the test will
+always be faster.
+
+```ruby
+# Experimental switch from `create` to `build_stubbed`
+Fast.shortcut(:exp_build_stubbed) do
+  require 'fast/experiment'
+  Fast.experiment('FactoryBot/UseBuildStubbed') do
+  lookup ARGV.last
+    search '(send nil create)'
+    edit { |node| replace(node.loc.selector, 'build_stubbed') }
+    policy { |new_file| system("bundle exec rspec --fail-fast #{new_file}") }
+  end.run
+end
+```
+## RSpec: Use `let_it_be` instead of `let`
+
+The `let_it_be` is a simple helper from
+[TestProf](https://test-prof.evilmartians.io/#/let_it_be) gem that can speed up
+the specs by caching some factories using like a `before_all` approach.
+
+This experiment hunts  for `let(...) { create(...) }` and switch the `let` to
+`let_it_be`:
+
+```ruby
+# Experimental replace `let(_)`  with `let_it_be` case it calls `create` inside the block
+Fast.shortcut(:exp_let_it_be) do
+  require 'fast/experiment'
+  Fast.experiment('FactoryBot/LetItBe') do
+    lookup ARGV.last
+    search '(block (send nil let (sym _)) (args) (send nil create))'
+    edit { |node| replace(node.children.first.loc.selector, 'let_it_be') }
+    policy { |new_file| system("bin/spring rspec --fail-fast #{new_file}") }
+  end.run
+end
+```
+
+## RSpec: Remove `before` or `after` blocks
+
+From time to time, we forget some left overs like `before` or `after` blocks
+that even removing from the code, the tests still passes. This experiment
+removes the before/after blocks and check if the test passes.
+
+```ruby
+# Experimental remove `before` or `after` blocks.
+Fast.shortcut(:exp_remove_before_after) do
+  require 'fast/experiment'
+  Fast.experiment('RSpec/RemoveBeforeAfter') do
+    lookup ARGV.last
+    search '(block (send nil {before after}))'
+    edit { |node| remove(node.loc.expression) }
+    policy { |new_file| system("bin/spring rspec --fail-fast #{new_file}") }
+  end.run
+end
+```
+
+## RSpec: Show message chains
+
+I often forget the syntax and need to search for message chains on specs, so I
+created an shortcut for it.
+
+```ruby
+# Show RSpec message chains
+Fast.shortcut(:message_chains, '^^(send nil receive_message_chain)', 'spec')
+```
+
+## RSpec: Show nested assertions
+
+I love to use nested assertions and I often need examples to refer to them:
+
+```ruby
+# Show RSpec nested assertions with .and
+Fast.shortcut(:nested_assertions, '^^(send ... and)', 'spec')
+```
+

data/docs/videos.md

@@ -0,0 +1,12 @@
+# Videos
+
+- Grepping Ruby code like a boss: [RubyConf Brazil 2019 (Portuguese)](https://www.eventials.com/locaweb/jonatas-paganini-live-coding-grepping-ruby-code-like-a-boss/#_=_)
+
+- Introduction to [inline code](https://www.youtube.com/watch?v=KQXglNLUv7o).
+<iframe width="560" height="315" src="https://www.youtube.com/embed/KQXglNLUv7o" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+- [Making local variables inline](https://www.youtube.com/watch?v=JD44nhegCRs)
+<iframe width="560" height="315" src="https://www.youtube.com/embed/YN0s9kV1A2A" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+- [Making methods inline](https://www.youtube.com/watch?v=JD44nhegCRs)
+<iframe width="560" height="315" src="https://www.youtube.com/embed/YN0s9kV1A2A" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

data/fast.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'astrolabe'
   spec.add_dependency 'coderay'
+  spec.add_dependency 'parallel'
   spec.add_dependency 'parser'
   spec.add_dependency 'pry'
 

data/lib/fast.rb

@@ -108,25 +108,50 @@ module Fast
     # @param [String] pattern
     # @param [Array<String>] *locations where to search. Default is '.'
     # @return [Hash<String,Array<Astrolabe::Node>>] with files and results
-    def search_all(pattern, locations = ['.'])
-      search_pattern = method(:search_file).curry.call(pattern)
-      group_results(search_pattern, locations)
+    def search_all(pattern, locations = ['.'], parallel: true, on_result: nil)
+      group_results(build_grouped_search(:search_file, pattern, on_result),
+                    locations, parallel: parallel)
     end
 
     # Capture with pattern on a directory or multiple files
     # @param [String] pattern
     # @param [Array<String>] locations where to search. Default is '.'
     # @return [Hash<String,Object>] with files and captures
-    def capture_all(pattern, locations = ['.'])
-      capture_pattern = method(:capture_file).curry.call(pattern)
-      group_results(capture_pattern, locations)
+    def capture_all(pattern, locations = ['.'], parallel: true, on_result: nil)
+      group_results(build_grouped_search(:capture_file, pattern, on_result),
+                    locations, parallel: parallel)
+    end
+
+    # @return [Proc] binding `pattern` argument from a given `method_name`.
+    # @param [Symbol] method_name with `:capture_file` or `:search_file`
+    # @param [String] pattern to match in a search to any file
+    # @param [Proc] on_result is a callback that can be notified soon it matches
+    def build_grouped_search(method_name, pattern, on_result)
+      search_pattern = method(method_name).curry.call(pattern)
+      proc do |file|
+        results = search_pattern.call(file)
+        next if results.nil? || results.empty?
+
+        on_result&.(file, results)
+        { file => results }
+      end
     end
 
-    def group_results(search_pattern, locations)
-      ruby_files_from(*locations)
-        .map { |f| { f => search_pattern.call(f) } }
-        .reject { |results| results.values.all?(&:empty?) }
-        .inject(&:merge!)
+    # Compact grouped results by file allowing parallel processing.
+    # @param [Proc] group_files allows to define a search that can be executed
+    # parallel or not.
+    # @param [Proc] on_result allows to define a callback for fast feedback
+    # while it process several locations in parallel.
+    # @param [Boolean] parallel runs the `group_files` in parallel
+    # @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!)
     end
 
     # Capture elements from searches in files. Keep in mind you need to use `$`
@@ -154,19 +179,16 @@ module Fast
       end
     end
 
-    # Return only captures from a search
+    # Only captures from a search
     # @return [Array<Object>] with all captured elements.
-    # @return [Object] with single element when single capture.
     def capture(pattern, node)
-      res = if (match = match?(pattern, node))
-              match == true ? node : match
-            else
-              node.each_child_node
-                .flat_map { |child| capture(pattern, child) }
-                .compact.flatten
-            end
-      res = [res] unless res.is_a?(Array)
-      res.one? ? res.first : res
+      if (match = match?(pattern, node))
+        match == true ? node : match
+      else
+        node.each_child_node
+          .flat_map { |child| capture(pattern, child) }
+          .compact.flatten
+      end
     end
 
     def expression(string)

data/lib/fast/cli.rb

@@ -69,6 +69,10 @@ module Fast
           @show_sexp = true
         end
 
+        opts.on('-p', '--parallel', 'Paralelize search') do
+          @parallel = true
+        end
+
         opts.on('--captures', 'Print only captures of the patterns and skip node results') do
           @captures = true
         end
@@ -129,6 +133,8 @@ module Fast
 
     # Show help or search for node patterns
     def run!
+      raise 'pry and parallel options are incompatible :(' if @parallel && @pry
+
       if @help || @files.empty? && @pattern.nil?
         puts option_parser.help
       else
@@ -137,6 +143,7 @@ module Fast
     end
 
     # Create fast expression from node pattern using the command line
+    # @return [Array<Fast::Find>] with the expression from string.
     def expression
       Fast.expression(@pattern)
     end
@@ -146,24 +153,29 @@ module Fast
     # If capture option is enabled it will only print the captures, otherwise it
     # prints all the results.
     def search
-      if debug_mode?
-        Fast.debug { execute_search }
-      else
-        execute_search do |file, results|
-          results.each do |result|
-            binding.pry if @pry # rubocop:disable Lint/Debugger
-            report(result, file)
-          end
+      return Fast.debug(&method(:execute_search)) if debug_mode?
+
+      execute_search do |file, results|
+        results.each do |result|
+          binding.pry if @pry # rubocop:disable Lint/Debugger
+          report(file, result)
         end
       end
     end
 
-    def execute_search
-      method_name = @captures ? :capture_all : :search_all
-      (Fast.public_send(method_name, expression, @files) || []).each do |file, results|
-        results = [results] unless results.is_a?(Array)
-        yield file, results
-      end
+    # Executes search for all files yielding the results
+    # @yieldparam [String, Array] with file and respective search results
+    def execute_search(&on_result)
+      Fast.public_send(search_method_name,
+                       expression,
+                       @files,
+                       parallel: parallel?,
+                       on_result: on_result)
+    end
+
+    # @return [Symbol] with `:capture_all` or `:search_all` depending the command line options
+    def search_method_name
+      @captures ? :capture_all : :search_all
     end
 
     # @return [Boolean] true when "-d" or "--debug" option is passed
@@ -176,9 +188,13 @@ module Fast
       puts(info) if debug_mode?
     end
 
+    def parallel?
+      @parallel == true
+    end
+
     # Report results using the actual options binded from command line.
     # @see Fast.report
-    def report(result, file)
+    def report(file, result)
       Fast.report(result, file: file, show_sexp: @show_sexp, headless: @headless, colorize: @colorize)
     end
 
@@ -198,7 +214,10 @@ module Fast
     # Prints available shortcuts as extra help and exit with code 1.
     def exit_shortcut_not_found(name)
       puts "Shortcut \033[1m#{name}\033[0m not found :("
-      puts "Available shortcuts are: #{Fast.shortcuts.keys.join(', ')}." if Fast.shortcuts.any?
+      if Fast.shortcuts.any?
+        puts "Available shortcuts are: #{Fast.shortcuts.keys.join(', ')}."
+        Fast.load_fast_files!
+      end
       exit 1
     end
   end

data/lib/fast/shortcut.rb

@@ -66,7 +66,7 @@ module Fast
     # the options from previous alias and replacing the files with the
     # @param [Array] extra_args
     def merge_args(extra_args)
-      [params[0], *options, *extra_args]
+      [params[0], *options, *extra_args.select(&File.method(:exists?))]
     end
 
     # If the shortcut was defined with a single block and no extra arguments, it

data/lib/fast/version.rb

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

data/mkdocs.yml

@@ -18,5 +18,8 @@ nav:
   - Syntax: syntax.md
   - Command Line: command_line.md
   - Experiments: experiments.md
+  - Shortcuts: shortcuts.md
   - Code Similarity: similarity_tutorial.md
   - Pry Integration: pry-integration.md
+  - Editors' Integration: editors-integration.md
+  - Videos: videos.md

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffast
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Jônatas Davi Paganini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-18 00:00:00.000000000 Z
+date: 2019-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: astrolabe
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  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: parser
   requirement: !ruby/object:Gem::Requirement
@@ -247,11 +261,14 @@ files:
 - bin/fast-experiment
 - bin/setup
 - docs/command_line.md
+- docs/editors-integration.md
 - docs/experiments.md
 - docs/index.md
 - docs/pry-integration.md
+- docs/shortcuts.md
 - docs/similarity_tutorial.md
 - docs/syntax.md
+- docs/videos.md
 - examples/build_stubbed_and_let_it_be_experiment.rb
 - examples/experimental_replacement.rb
 - examples/find_usage.rb
@@ -291,7 +308,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: 'FAST: Find by AST.'