ffast 0.2.0 → 0.2.3

data/docs/command_line.md

@@ -1,238 +0,0 @@
-# Command line
-
-When you install the ffast gem, it will also create an executable named `fast` 
-and you can use it to search and find code using the concept:
-
-```
-$ fast '(def match?)' lib/fast.rb
-```
-- Use `-d` or `--debug` for enable debug mode.
-- Use `--ast` to output the AST instead of the original code
-- 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`
-
-    $ fast '(block (send nil it))' spec --pry
-
-And inside pry session,  you can use `result` as the first result or `results`
-to use all occurrences found.
-
-```ruby
-results.map{|e|e.children[0].children[2]}
-# => [s(:str, "parses ... as Find"),
-# s(:str, "parses $ as Capture"),
-# s(:str, "parses quoted values as strings"),
-# s(:str, "parses {} as Any"),
-# s(:str, "parses [] as All"), ...]
-```
-
-Getting all `it` blocks without description:
-
-    $ fast '(block (send nil it (nil)) (args ) (!str)) ) )' spec
-
-```ruby
-# spec/fast_spec.rb:166
-it { expect(described_class).to be_match('(...)', s(:int, 1)) }
-...
-```
-
-## `--debug`
-
-This option will print all matching details while validating each node.
-
-```
-$ echo 'object.method' > sample.rb
-$ fast -d '(send (send nil _) _)' sample.rb
-```
-
-It will bring details of the expression compiled and each node being validated:
-
-```
-Expression: f[send] [#<Fast::Find:0x00007f8c53047158 @token="send">, #<Fast::Find:0x00007f8c530470e0 @token="nil">, #<Fast::Find:0x00007f8c53047090 @token="_">] f[_]
-send == (send
-  (send nil :object) :method) # => true
-f[send] == (send
-  (send nil :object) :method) # => true
-send == (send nil :object) # => true
-f[send] == (send nil :object) # => true
- ==  # => true
-f[nil] ==  # => true
-#<Proc:0x00007f8c53057af8@/Users/jonatasdp/.rbenv/versions/2.5.1/lib/ruby/gems/2.5.0/gems/ffast-0.0.2/lib/fast.rb:25 (lambda)> == object # => true
-f[_] == object # => true
-[#<Fast::Find:0x00007f8c53047158 @token="send">, #<Fast::Find:0x00007f8c530470e0 @token="nil">, #<Fast::Find:0x00007f8c53047090 @token="_">] == (send nil :object) # => true
-#<Proc:0x00007f8c53057af8@/Users/jonatasdp/.rbenv/versions/2.5.1/lib/ruby/gems/2.5.0/gems/ffast-0.0.2/lib/fast.rb:25 (lambda)> == method # => true
-f[_] == method # => true
-# sample.rb:1
-object.method
-```
-
-## `-s` for similarity
-
-Sometimes you want to search for some similar code like `(send (send (send nil _) _) _)` and we could simply say `a.b.c`.
-
-The option `-s` build an expression from the code ignoring final values.
-
-    $ echo 'object.method' > sample.rb
-    $ fast -s 'a.b' sample.rb
-
-```ruby
-# sample.rb:1
-object.method
-```
-
-See also [Code Similarity](similarity_tutorial.md) tutorial.
-
-## `-c` to search from code example
-
-You can search  for the exact expression with `-c`
-
-    $ fast -c 'object.method' sample.rb
-
-```ruby
-# sample.rb:1
-object.method
-```
-
-Combining with `-d`, in the header you can see the generated expression.
-
-```
-$ fast -d -c 'object.method' sample.rb | head -n 3
-
-The generated expression from AST was:
-(send
-  (send nil :object) :method)
-```
-
-## Fastfile
-
-`Fastfile` will loaded when you start a pattern with a dot. It means the pattern
-will be a shortcut predefined on these Fastfiles.
-
-It will make three attempts to load `Fastfile` defined in `$PWD`, `$HOME` or
-checking if the `$FAST_FILE_DIR` is configured.
-
-You can define a `Fastfile` in any project with your custom shortcuts and easy
-check some code or run some task.
-
-
-## Shortcut examples
-
-Create shortcuts with blocks enables introduce custom coding in
-the scope of the `Fast` module.
-
-### Print library version.
-
-Let's say you'd like to show the version of your library. Your regular params
-in the command line will look like:
-
-    $ fast '(casgn nil VERSION)' lib/*/version.rb
-
-It will output but the command is not very handy. In order to just say `fast .version`
-you can use the previous snippet in your `Fastfile`.
-
-```ruby
-Fast.shortcut(:version, '(casgn nil VERSION)', 'lib/fast/version.rb')
-```
-
-And calling `fast .version` it will output something like this:
-
-```ruby
-# lib/fast/version.rb:4
-VERSION = '0.1.2'
-```
-
-We can also always override the files params passing some other target file
-like `fast .version lib/other/file.rb` and it will reuse the other arguments
-from command line but replace the target files.
-
-### Bumping a gem version
-
-While releasing a new gem version, we always need to mechanical go through the
-`lib/<your_gem>/version.rb` and change the string value to bump the version
-of your library. It's pretty mechanical and here is an example that allow you 
-to simple use `fast .bump_version`:
-
-```ruby
-Fast.shortcut :bump_version do
-  rewrite_file('lib/fast/version.rb', '(casgn nil VERSION (str _)') 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
-```
-
-!!! note "Note the shortcut scope"
-    The shortcut calls `rewrite_file` from `Fast` scope as it use
-    `Fast.instance_exec` for shortcuts that yields blocks.
-
-Checking the version:
-
-```bash
-$ fast .version                                                                                                                                                                                                                            13:58:40
-# lib/fast/version.rb:4
-VERSION = '0.1.2'
-```
-Bumping the version:
-
-```bash
-$ fast .bump_version                                                                                                                                                                                                                       13:58:43
-```
-
-No output because we don't print anything. Checking version again:
-
-```bash
-$ fast .version                                                                                                                                                                                                                            13:58:54
-# lib/fast/version.rb:4
-VERSION = '0.1.3'
-```
-
-And now a fancy shortcut to report the other shortcuts :)
-
-```ruby
-Fast.shortcut :shortcuts do
-  report(shortcuts.keys)
-end
-```
-
-Or we can make it a bit more friendly and also use Fast to process the shortcut
-positions and pick the comment that each shortcut have in the previous line: 
-
-```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 it will be printing all loaded shortcuts with comments:
-
-```
-$ fast .shortcuts
-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
-```
-
-You can find more examples in the [Fastfile](https://github.com/jonatas/fast/tree/master/Fastfile).
-

data/docs/editors-integration.md

@@ -1,46 +0,0 @@
-# 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/experiments.md

@@ -1,153 +0,0 @@
-# Experiments
-
-Experiments allow us to play with AST and do some code transformation, execute
-some code and continue combining successful transformations.
-
-The major idea is try a new approach without any promise and if it works
-continue transforming the code.
-
-## Replace `FactoryBot#create` with `build_stubbed`.
-
-Let's look into the following spec example:
-
-```ruby
-describe "my spec" do
-  let(:user) { create(:user) }
-  let(:address) { create(:address) }
-  # ...
-end
-```
-
-Let's say we're amazed with `FactoryBot#build_stubbed` and want to build a small
-bot to make the changes in a entire code base. Skip some database
-touches while testing huge test suites are always a good idea.
-
-First we can hunt for the cases we want to find:
-
-```
-$ ruby-parse -e "create(:user)"
-(send nil :create
-  (sym :user))
-```
-
-Using `fast` in the command line to see real examples in the `spec` folder:
-
-```
-$ fast "(send nil create)" spec
-```
-
-If you don't have a real project but want to test, just create a sample ruby
-file with the code example above.
-
-Running it in a big codebase will probably find a few examples of blocks.
-
-The next step is build a replacement of each independent occurrence to use
-`build_stubbed` instead of create and combine the successful ones, run again and
-combine again, until try all kind of successful replacements combined.
-
-Considering we have the following code in `sample_spec.rb`:
-
-```ruby
-describe "my spec" do
-  let(:user) { create(:user) }
-  let(:address) { create(:address) }
-  # ...
-end
-```
-
-Let's create the experiment that will contain the nodes that are target to be
-executed and what we want to do when we find the node.
-
-```ruby
-experiment = Fast.experiment('RSpec/ReplaceCreateWithBuildStubbed') do
-  search '(send nil create)'
-  edit { |node| replace(node.loc.selector, 'build_stubbed') }
-end
-```
-
-If we use `Fast.replace_file` it will replace all occurrences in the same run
-and that's one of the motivations behind create the `ExperimentFile` class.
-
-Executing a partial replacement of the first occurrence:
-
-```ruby
-experiment_file = Fast::ExperimentFile.new('sample_spec.rb', experiment) }
-puts experiment_file.partial_replace(1)
-```
-
-The command will output the following code:
-
-```ruby
-describe "my spec" do
-  let(:user) { build_stubbed(:user) }
-  let(:address) { create(:address) }
-  # ...
-end
-```
-
-## Remove useless before block
-
-Imagine the following code sample:
-
-```ruby
-describe "my spec" do
-  before { create(:user) }
-  # ...
-  after { User.delete_all }
-end
-```
-
-And now, we can define an experiment that removes the entire code block and run
-the experimental specs.
-
-```ruby
-experiment = 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
-```
-
-To run the experiment you can simply say:
-
-```ruby
-experiment.run
-```
-
-Or drop the code into `experiments` folder and use the `fast-experiment` command
-line tool.
-
-    $ fast-experiment RSpec/RemoveUselessBeforeAfterHook spec
- 
-## DSL
-
-- In the `lookup` you can pass files or folders.
-- The `search` contains the expression you want to match
-- With `edit` block you can apply the code change
-- And the `policy` is executed to check if the current change is valuable
-
-If the file contains multiple `before` or `after` blocks, each removal will
-occur independently and the successfull removals will be combined as a
-secondary change. The process repeates until find all possible combinations.
-
-See more examples in [experiments](experiments) folder.
-
-To run multiple experiments, use `fast-experiment` runner:
-
-```
-fast-experiment <experiment-names> <files-or-folders>
-```
-
-You can limit experiments or file escope:
-
-```
-fast-experiment RSpec/RemoveUselessBeforeAfterHook spec/models/**/*_spec.rb
-```
-
-Or a single file:
-
-```
-fast-experiment RSpec/ReplaceCreateWithBuildStubbed spec/models/my_spec.rb
-```
-

data/docs/ideas.md

@@ -1,80 +0,0 @@
-# Ideas I want to build with Fast
-
-I don't have all the time I need to develop all the ideas I have to build
-around this tool, so here is a dump of a few brainstormings:
-
-## Inline target code
-
-I started [fast-inline](https://github.com/jonatas/fast-inline) that can be
-useful to try to see how much every library is used in a project.
-
-My idea is try to inline some specific method call to understand if it makes
-sense to have an entire library in the stock.
-
-Understanding dependencies and how the code works can be a first step to get an
-"algorithm as a service". Instead of loading everything from the library, it
-would facilitate the cherry pick of only the proper dependencies necessaries to
-run the code you have and not the code that is overloading the project.
-
-## Neo4J adapter
-
-Easy pipe fast results to Neo4J. It would facilitate to explore more complex
-scenarios and combine data from other sources.
-
-## Git adapter
-
-Add extra tags to nodes with information from Git.
-
-* Revision
-* Author
-* Date
-
-Tag every node with the proper author.
-
-## Ast Diff
-
-Allow to compare and return a summary of differences between two trees.
-
-It would be useful to identify renamings or other small changes, like only
-changes in comments that does not affect the file and possibly be ignored for
-some operations like run or not run tests.
-
-## Transition synapses
-
-Following the previous idea, it would be great if we can understand the
-transition synapses and make it easily available to catch up with previous
-learnings.
-
-https://github.com/jonatas/chewy-diff/blob/master/lib/chewy/diff.rb
-
-This example, shows adds and removals from specific node targets between two
-different files.
-
-If we start tracking AST transition synapses and associating with "Fixes" or
-"Reverts" we can predict introduction of new bugs by inpecting if the
-introduction of new patterns that can be possibly reverted or improved.
-
-## Fast Rewriter with pure strings
-
-As the AST rewriter adopts a custom block that needs to implement ruby code,
-we can expand the a query language for rewriting files without need to take the
-custom Ruby block.
-
-Example:
-
-```ruby
-Fast.gsub_expression('remove(@expression)') # (node) => { remove(node.location.expression) }
-```
-
-And later we can bind it in the command line to allow implement custom
-replacements without need to write a ruby file.
-
-```
-fast (def my_target_method) lib spec --rewrite "remove(@expression)"
-```
-
-or
-
-```
-fast (def my_target_method) lib spec --rewrite "replace(@name, 'renamed_method')"
-```