ffast 0.2.2 → 0.2.3

data/docs/walkthrough.md

@@ -1,135 +0,0 @@
-# Fast walkthrough
-
-!!! note "This is the main interactive tutorial we have on `fast`. If you're reading it on the web, please consider also try it in the command line: `fast .intro` in the terminal to get a rapid pace on reading and testing on your own computer."
-
-The objective here is give you some insights about how to use `ffast` gem in the
-command line.
-
-Let's start finding the main `fast.rb` file for the fast library:
-
-```
-$ gem which fast
-```
-
-And now, let's combine the previous expression that returns the path to the file
-and take a quick look into the methods `match?` in the file using a regular grep:
-
-```
-$ grep "def match\?" $(gem which fast)
-```
-
-Boring results, no? The code here is not easy to digest because we just see a
-fragment of the code block that we want.
-Let's make it a bit more advanced with `grep -rn` to file name and line number:
-
-```
-$ grep -rn "def match\?" $(gem which fast)
-```
-
-Still hard to understand the scope of the search.
-
-That's why fast exists! Now, let's take a look on how a method like this looks
-like from the AST perspective. Let's use `ruby-parse` for it:
-
-```
-$ ruby-parse -e "def match?(node); end"
-```
-
-Now, let's make the same search with `fast` node pattern:
-
-```
-fast "(def match?)" $(gem which fast)
-```
-
-Wow! in this case you got all the `match?` methods, but you'd like to go one level upper
-and understand the classes that implements the method with a single node as
-argument. Let's first use `^` to jump into the parent:
-
-```
-fast "^(def match?)" $(gem which fast)
-```
-
-As you can see it still prints some `match?` methods that are not the ones that
-we want, so, let's add a filter by the argument node `(args (arg node))`:
-
-```
-fast "(def match? (args (arg node)))" $(gem which fast)
-```
-
-Now, it looks closer to have some understanding of the scope, filtering only
-methods that have the name `match?` and receive `node` as a parameter.
-
-Now, let's do something different and find all methods that receives a `node` as
-an argument:
-
-```
-fast "(def _ (args (arg node)))" $(gem which fast)
-```
-
-Looks like almost all of them are the `match?` and we can also skip the `match?`
-methods negating the expression prefixing with `!`:
-
-```
-fast "(def !match? (args (arg node)))" $(gem which fast)
-```
-
-Let's move on and learn more about node pattern with the RuboCop project:
-
-```
-$ VISUAL=echo gem open rubocop
-```
-
-RuboCop contains `def_node_matcher` and `def_node_search`. Let's make a search
-for both method names wrapping the query with `{}` selector:
-
-```
-fast "(send nil {def_node_matcher def_node_search})" $(VISUAL=echo gem open rubocop)
-```
-
-As you can see, node pattern is widely adopted in the cops to target code.
-Rubocop contains a few projects with dedicated cops that can help you learn
-more.
-
-## How to automate refactor using AST
-
-Moving towards to the code automation, the next step after finding some target code
-is refactor and change the code behavior.
-
-Let's imagine that we already found some code that we want to edit or remove. If
-we get the AST we can also cherry-pick any fragment of the expression to be
-replaced. As you can imagine, RuboCop also benefits from automatic refactoring
-offering the `--autocorrect` option.
-
-All the hardcore algorithms are in the [parser](https://github.com/whitequark/parser)
-rewriter, but we can find a lot of great examples on RuboCop project searching
-for the `autocorrect` method.
-
-```
-fast "(def autocorrect)" $(VISUAL=echo gem open rubocop)
-```
-
-Look that most part of the methods are just returning a lambda with a
-corrector. Now, let's use the `--ast` to get familiar with the tree details for the
-implementation:
-
-```
-fast --ast "(def autocorrect)" $(VISUAL=echo gem open rubocop)/lib/rubocop/cop/style
-```
-
-As we can see, we have a `(send (lvar corrector))` that is the interface that we
-can get the most interesting calls to overwrite files:
-
-```
-fast "(send (lvar corrector)" $(VISUAL=echo gem open rubocop)
-```
-
-
-## That is all for now!
-
-I hope you enjoyed to learn by example searching with fast. If you like it,
-please [star the project](https://github.com/jonatas/fast/)!
-
-You can also build your own tutorials simply using markdown files like I did
-here, you can find this tutorial [here](https://github.com/jonatas/fast/tree/master/docs/walkthrough.md).
-
-

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