ffast 0.2.0 → 0.2.3

data/docs/syntax.md

@@ -1,395 +0,0 @@
-# Syntax
-
-The syntax is inspired on [RuboCop Node Pattern](https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb).
-
-You can find a great tutorial about RuboCop node pattern in the
-[official documentation](https://rubocop.readthedocs.io/en/latest/node_pattern/).
-
-## Code example
-
-Let's consider the following `example.rb` code example:
-
-```ruby
-class Example
-  ANSWER = 42
-  def magic
-    rand(ANSWER)
-  end
-  def duplicate(value)
-    value * 2
-  end
-end
-```
-
-Looking the AST representation we have:
-
-    $ ruby-parse example.rb
-
-```
-(class
-  (const nil :Example) nil
-  (begin
-    (casgn nil :ANSWER
-      (int 42))
-    (def :magic
-      (args)
-      (send nil :rand
-        (const nil :ANSWER)))
-    (def :duplicate
-      (args
-        (arg :value))
-      (send
-        (lvar :value) :*
-        (int 2)))))
-```  
-
-Now, let's explore all details of the current AST, combining with the syntax
-operators.
-
-Fast works with a single word that will be the node type.
-
-A simple search of `def` nodes can be done and will also print the code.
-
-    $ fast def example.rb
-
-```ruby
-# example.rb:3
-  def magic
-    rand(ANSWER)
-  end
-```
-
-or check the `casgn` that will show constant assignments:
-
-    $ fast casgn example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-```
-
-## `()` to represent a **node** search
-
-To specify details about a node, the `(` means navigate deeply into a node and
-go deep into the expression.
-
-    $ fast '(casgn' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-```
-
-Fast matcher never checks the end of the expression and close parens are not
-necessary. We keep them for the sake of specify more node details but the
-expression works with incomplete parens.
-
-    $ fast '(casgn)' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-```
-
-Closing extra params also don't have a side effect.
-
-    $ fast '(casgn))' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-```
-
-It also automatically flat parens case you put more levels in the beginning.
-
-    $ fast '((casgn))' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-```
-
-For checking AST details while doing some search, you can use `--ast` in the
-command line for printing the AST instead of the code:
-
-    $ fast '((casgn ' example.rb --ast
-
-```ruby
-# example.rb:2
-(casgn nil :ANSWER
-  (int 42))
-```
-
-## `_` is **something** not nil
-
-Let's enhance our current expression and specify that we're looking for constant
-assignments of integers ignoring values and constant names replacing with `_`.
-
-    $ fast '(casgn nil _ (int _))' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-```
-
-Keep in mind that `_` means not nil and  `(casgn _ _ (int  _))` would not
-match.
-
-Let's search for integer nodes:
-
-    $ fast int example.rb
-```ruby
-# example.rb:2
-42
-# example.rb:7
-2
-```
-
-The current search show the nodes but they are not so useful without understand
-the expression in their context. We need to check their `parent`.
-
-## `^` is to get the **parent node** of an expression
-
-By default, Parser::AST::Node  does not have access to parent and for accessing
-it you can say `^` for reaching the parent.
-
-    $ fast '^int' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-# example.rb:7
-value * 2
-```
-
-And using it multiple times will make the node match from levels up:
-
-    $ fast '^^int' example.rb
-
-```ruby
-# example.rb:2
-ANSWER = 42
-  def magic
-    rand(ANSWER)
-  end
-  def duplicate(value)
-    value * 2
-  end
-```
-
-## `[]` join conditions
-
-Let's hunt for integer nodes that the parent is also a method:
-
-    $ fast '[ ^^int def ]' example.rb
-
-The match will filter only nodes that matches all internal expressions.
-
-```ruby
-# example.rb:6
-def duplicate(value)
-    value * 2
-  end
-```
-
-The expression is matching nodes that have a integer granchild and also with
-type `def`.
-
-## `...` is a **node** with children
-
-Looking the method representation we have:
-
-    $ fast def example.rb --ast
-
-```ruby
-# example.rb:3
-(def :magic
-  (args)
-  (send nil :rand
-    (const nil :ANSWER)))
-# example.rb:6
-(def :duplicate
-  (args
-    (arg :value))
-  (send
-    (lvar :value) :*
-    (int 2)))
-```
-
-And if we want to delimit only methods with arguments:
-
-    $ fast '(def _ ...)' example.rb
-
-```ruby
-# example.rb:6
-def duplicate(value)
-    value * 2
-  end
-```
-
-If we use `(def _ _)` instead it will match both methods because `(args)` 
-does not have children but is not nil.
-
-## `$` is for **capture** current expression
-
-Now, let's say we want to extract some method name from current classes.
-
-In such case we don't want to have the node definition but only return the node
-name.
-
-```ruby
-# example.rb:2
-def magic
-    rand(ANSWER)
-  end
-# example.rb:
-magic
-# example.rb:9
-def duplicate(value)
-    value * 2
-  end
-# example.rb:
-duplicate
-```
-
-One extra method name was printed because of `$` is capturing the element.
-
-## `nil` matches exactly **nil**
-
-Nil is used in the code as a node type but parser gem also represents empty
-spaces in expressions with nil.
-
-Example, a method call from Kernel is a `send` from `nil` calling the method
-while I can also send a method call from a class.
-
-```
-$ ruby-parse -e 'method'
-(send nil :method)
-```
-
-And a method from a object will have the nested target not nil.
-
-```
-$ ruby-parse -e 'object.method'
-(send
-  (send nil :object) :method)
-```
-
-Let's build a serch for any calls from `nil`:
-
-    $ fast '(_ nil _)' example.rb
-
-```ruby
-# example.rb:3
-Example
-# example.rb:4
-ANSWER = 42
-# example.rb:6
-rand(ANSWER)
-```
-
-Double check the expressions that have matched printing the AST:
-
-    $ fast '(_ nil _)' example.rb --ast
-
-```ruby
-# example.rb:3
-(const nil :Example)
-# example.rb:4
-(casgn nil :ANSWER
-  (int 42))
-# example.rb:6
-(send nil :rand
-  (const nil :ANSWER))
-```
-
-## `{}` is for **any** matches like **union** conditions with **or** operator
-
-Let's say we to add check all occurrencies of the constant `ANSWER`.
-
-We'll need to get both `casgn` and `const` node types. For such cases we can
-surround the expressions with `{}` and it will return if the node matches with
-any of the internal expressions.
-
-    $ fast '({casgn const} nil ANSWER)' example.rb
-
-```
-# example.rb:4
-ANSWER = 42
-# example.rb:6
-ANSWER
-```
-
-## `#` for custom methods
-
-Custom methods can let you into ruby doman for more complicated rules. Let's say
-we're looking for duplicated methods in the same class. We need to collect
-method names and guarantee they are unique.
-
-```ruby
-def duplicated(method_name)
-  @methods ||= []
-  already_exists = @methods.include?(method_name)
-  @methods << method_name
-  already_exists
-end
-
-puts Fast.search_file( '(def #duplicated)', 'example.rb')
-```
-The same principle can be used in the node level or for debugging purposes.
-
-```ruby
-require 'pry'
-def debug(node)
-  binding.pry
-end
-
-puts Fast.search_file('#debug', 'example.rb')
-```
-If you want to get only `def` nodes you can also intersect expressions with `[]`:
-```ruby
-puts Fast.search_file('[ def #debug ]', 'example.rb')
-```
-Or if you want to debug a very specific expression you can use `()` to specify
-more details of the node
-```ruby
-puts Fast.search_file('[ (def a) #debug ]', 'example.rb')
-```
-
-## `.` for instance methods
-
-You can also call instance methods using `.<method-name>`.
-
-Example `nil` is the same of calling `nil?` and you can also use `(int .odd?)`
-to pick only odd integers. The `int` fragment can also be `int_type?`.
-
-## `\1` for first previous capture
-
-Imagine you're looking for a method that is just delegating something to
-another method, like:
-
-```ruby
-def name
-  person.name
-end
-```
-
-This can be represented as the following AST:
-
-```
-(def :name
-  (args)
-  (send
-    (send nil :person) :name))
-```
-
-Then, let's build a search for methods that calls an attribute with the same
-name:
-
-```ruby
-Fast.match?('(def $_ ... (send (send nil _) \1))', ast) # => [:name]
-```
-
-With the method name being captured with `$_` it can be later referenced in the
-expression with `\1`. If the search contains multiple captures, the `\2`,`\3`
-can be used as the sequence of captures.

data/docs/videos.md

@@ -1,16 +0,0 @@
-# Videos
-
-- [Ruby Kaigi TakeOut 2020: Grepping Ruby code like a boss](https://www.youtube.com/watch?v=YzcYXB4L2so&feature=youtu.be&t=11855)
-
-<iframe width="560" height="315" src="https://www.youtube.com/embed/YzcYXB4L2so?start=11855" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
-
-Also, similar livecoding session at [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/examples/build_stubbed_and_let_it_be_experiment.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'fast'
-require 'open3'
-require 'ostruct'
-require 'fileutils'
-
-# Usage instructions:
-# 1. Add the following to your project's Gemfile: gem 'ffast' (yes, two "f"s)
-# 2. Copy this file to your Rails project root directory
-# 3. Run: bundle exec ruby build_stubbed_and_let_it_be_experiment.rb
-
-# List of spec files you want to experiment with. One per line.
-FILE_NAMES = %w[
-  # spec/model/foo_spec.rb
-  # spec/model/bar_spec.rb
-]
-
-def execute_rspec(file_name)
-  rspec_command = "bin/spring rspec --fail-fast --format progress #{file_name}"
-  stdout_str, stderr_str, status = Open3.capture3(rspec_command)
-  execution_time = /Finished in (.*?) seconds/.match(stdout_str)[1]
-  print stderr_str.gsub(/Running via Spring preloader.*?$/, '').chomp unless status.success?
-  OpenStruct.new(success: status.success?, execution_time: execution_time)
-end
-
-def delete_temp_files(original_file_name)
-  file_path = File.dirname(original_file_name)
-  file_name = File.basename(original_file_name)
-  Dir.glob("#{file_path}/experiment*#{file_name}").each { |file| File.delete(file)}
-end
-
-FILE_NAMES.each do |original_file_name|
-  Fast.experiment('RSpec/ReplaceCreateWithBuildStubbed') do
-    lookup original_file_name
-    search '(block (send nil let (sym _)) (args) $(send nil create))'
-    edit { |_, (create)| replace(create.loc.selector, 'build_stubbed') }
-    policy { |experiment_file_name| execute_rspec(experiment_file_name) }
-  end.run
-
-  Fast.experiment('RSpec/LetItBe') do
-    lookup original_file_name
-    search '(block $(send nil let! (sym _)) (args) (send nil create))'
-    edit { |_, (let)| replace(let.loc.selector, 'let_it_be') }
-    policy { |experiment_file_name| execute_rspec(experiment_file_name) }
-  end.run
-
-  delete_temp_files(original_file_name)
-end
-
-

data/examples/experimental_replacement.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path('../lib', __dir__)
-require 'fast'
-
-# It's a simple script that you can try to replace
-# `create` by `build_stubbed` and it moves the file if
-# successfully passed the specs
-#
-# $ ruby experimental_replacement.rb spec/*/*_spec.rb
-def experimental_spec(file, name)
-  parts = file.split('/')
-  dir = parts[0..-2]
-  filename = "experiment_#{name}_#{parts[-1]}"
-  File.join(*dir, filename)
-end
-
-def experiment(file, name, search, replacement)
-  ast = Fast.ast_from_file(file)
-
-  results = Fast.search(ast, search)
-  unless results.empty?
-    new_content = Fast.replace_file(file, search, replacement)
-    new_spec = experimental_spec(file, name)
-    return if File.exist?(new_spec)
-    File.open(new_spec, 'w+') { |f| f.puts new_content }
-    if system("bin/spring rspec --fail-fast #{new_spec}")
-      system "mv #{new_spec} #{file}"
-      puts "✅ #{file}"
-    else
-      system "rm #{new_spec}"
-      puts "🔴  #{file}"
-    end
-  end
-rescue StandardError
-  # Avoid stop because weird errors like encoding issues
-  puts "🔴🔴 🔴   #{file}: #{$ERROR_INFO}"
-end
-
-ARGV.each do |file|
-  [
-    # Thread.new { experiment(file, 'build_stubbed', '(send nil create)', ->(node) { replace(node.location.selector, 'build_stubbed') }) },
-    experiment(file, 'seed', '(send nil create)', ->(node) { replace(node.location.selector, 'seed') })
-
-  ] # .each(&:join)
-end

data/examples/find_usage.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# List files that matches with some expression
-# Usage:
-#
-# ruby examples/find_usage.rb defs
-#
-# Or be explicit about directory or folder:
-#
-# ruby examples/find_usage.rb defs lib/
-$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
-
-require 'fast'
-require 'coderay'
-
-arguments = ARGV
-pattern = arguments.shift
-files = Fast.ruby_files_from(arguments.any? ? arguments : '.')
-files.select do |file|
-  begin
-    puts file if Fast.search_file(pattern, file).any?
-  rescue Parser::SyntaxError
-    []
-  end
-end

data/examples/let_it_be_experiment.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require '../../fast/lib/fast'
-
-# For specs using `let(:something) { create ... }` it tries to use `let_it_be` instead
-Fast.experiment('RSpec/LetItBe') do
-  lookup 'spec/models'
-  search '(block $(send nil let (sym _)) (args) (send nil create))'
-  edit { |_, (let)| replace(let.loc.selector, 'let_it_be') }
-  policy { |new_file| system("bin/spring rspec --fail-fast #{new_file}") }
-end.run

data/examples/method_complexity.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path('../lib', __dir__)
-require 'fast'
-
-def node_size(node)
-  return 1 unless node.respond_to?(:children)
-  children = node.children
-  return 1 if children.empty? || children.length == 1
-  nodes, syms = children.partition { |e| e.respond_to?(:children) }
-  1 + syms.length + (nodes.map(&method(:node_size)).inject(:+) || 0)
-end
-
-def method_complexity(file)
-  ast = Fast.ast_from_file(file)
-  Fast.search(ast, '(class ...)').map do |node_class|
-    manager_name = node_class.children.first.children.last
-
-    defs = Fast.search(node_class, '(def !{initialize} ... ... )')
-
-    defs.map do |node|
-      complexity = node_size(node)
-      method_name = node.children.first
-      { "#{manager_name}##{method_name}" => complexity }
-    end.inject(:merge) || {}
-  end
-end
-
-files = ARGV || Dir['**/*.rb']
-
-complexities = files.map(&method(:method_complexity)).flatten.inject(:merge!)
-
-puts '| Method | Complexity |'
-puts '| ------ | ---------- |'
-complexities.sort_by { |_, v| -v }.map do |method, complexity|
-  puts "| #{method} | #{complexity} |"
-end

data/examples/search_duplicated.rb

@@ -1,15 +0,0 @@
-require 'fast'
-
-# Search for duplicated methods interpolating the method and collecting previous
-# method names. Returns true if the name already exists in the same class level.
-# Note that this example will work only in a single file because it does not
-# cover any detail on class level.
-def duplicated(method_name)
-  @methods ||= []
-  already_exists = @methods.include?(method_name)
-  @methods << method_name
-  already_exists
-end
-
-puts Fast.search_file( '(def #duplicated)', 'example.rb')
-

data/examples/similarity_research.rb

@@ -1,58 +0,0 @@
-require 'bundler/setup'
-require 'fast'
-require 'coderay'
-require 'pp'
-require 'set'
-
-arguments = ARGV
-pattern = arguments.shift || '{ block case send def defs while class if }'
-
-files = Fast.ruby_files_from(*%w(spec lib app gems)) +
-  Dir[File.join(Gem.path.first,'**/*.rb')]
-
-total = files.count
-pattern = Fast.expression(pattern)
-
-similarities = {}
-
-def similarities.show pattern
-  files = self[pattern]
-  files.each do |file|
-    nodes = Fast.search_file(pattern, file)
-    nodes.each do |result|
-      Fast.report(result, file: file)
-    end
-  end
-end
-
-def similarities.top
-  self.transform_values(&:size)
-  .sort_by{|search,results|search.size / results.size}
-  .reverse.select{|k,v|v > 10}[0,10]
-end
-
-begin
-  files.each_with_index do |file, i|
-    progress = ((i / total.to_f) * 100.0).round(2)
-    print "\r (#{i}/#{total})   #{progress}%     Researching on #{file}"
-    begin
-      results = Fast.search_file(pattern, file) || []
-    rescue
-      next
-    end
-    results.each do |n|
-      search = Fast.expression_from(n)
-      similarities[search] ||= Set.new
-      similarities[search] << file
-    end
-  end
-rescue Interrupt
-# require 'pry'; binding.pry
-end
-
-puts "mapped #{similarities.size} cases"
-similarities.delete_if {|k,v| k.size < 30 || v.size < 5}
-puts "Removing the small ones we have #{similarities.size} similarities"
-
-similarities.show similarities.top[0][0]
-

data/examples/simple_rewriter.rb

@@ -1,6 +0,0 @@
-
-rewriter = Fast::Rewriter.new
-rewriter.ast = Fast.ast("a = 1")
-rewriter.search ='(lvasgn _ ...)'
-rewriter.replacement =  -> (node) { replace(node.location.name, 'variable_renamed') }
-puts rewriter.rewrite!

data/experiments/let_it_be_experiment.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-# For specs using `let!(:something) { create ... }` it tries to use `let_it_be` instead
-Fast.experiment('RSpec/LetItBe') do
-  lookup 'spec'
-  search '(block $(send nil let! (sym _)) (args) (send nil create))'
-  edit { |_, (let)| replace(let.loc.selector, 'let_it_be') }
-  policy { |new_file| system("bin/spring rspec --fail-fast #{new_file}") }
-end

data/experiments/remove_useless_hook.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-# Experimentally remove a before or an after block
-Fast.experiment('RSpec/RemoveUselessBeforeAfterHook') do
-  lookup 'spec'
-  search '(block (send nil {before after}))'
-  edit { |node| remove(node.loc.expression) }
-  policy { |new_file| system("bin/spring rspec --fail-fast #{new_file}") }
-end

data/experiments/replace_create_with_build_stubbed.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-# For specs using `let(:something) { create ... }` it tries to use
-# `build_stubbed` instead
-Fast.experiment('RSpec/ReplaceCreateWithBuildStubbed') do
-  lookup 'spec'
-  search '(block (send nil let (sym _)) (args) $(send nil create))'
-  edit { |_, (create)| replace(create.loc.selector, 'build_stubbed') }
-  policy { |new_file| system("bin/spring rspec --format progress --fail-fast #{new_file}") }
-end