ffast 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97309977be2dabc51b9113ee555aa7fe94d21a52426bb7386bf1133696fc4b81
-  data.tar.gz: 5851dd6da013f0561803b73d7c44a96b35960a8323399d012718eb712cf42b43
+  metadata.gz: 3942d57d80b4c4a1cd1c8ff40f18cc56508a51f4b6cae53480536f7c36a60b05
+  data.tar.gz: b60976ea570cf722ae6face8541881c6a1231b2d645727f25231a05c9f33f7ee
 SHA512:
-  metadata.gz: 192e53811678fac65eb03d87145be85971079b832f0675c80d0644e1686765995aa591e955adcb7fad31f28b0a8a2cdea0cfeaee7db9fee9067f19a36f65fd5b
-  data.tar.gz: 024c2b9a6db910e16516bf54b71f9857af40edec50c180488c312e82b177968f13e9b11d795036ffdc0541e2413b55e2efd016f0a383b06265fc7d28f99dc01f
+  metadata.gz: c4df11570f2b2cc164dbd43815a37443541c98c955d6c84ea0b24564fd03b8534cf73479844393ecd72c794231ad40baf678784f9863a8f90c157ac8477f3c9d
+  data.tar.gz: d9481952776fc77d251a3c9f518f41e20d672298e9ff01b53b8673a0c0bc38f4919e4dd7234365e8044f5cef8e0738823d847900bea790f9796e6d8554342a06

data/.rubocop.yml

@@ -8,11 +8,114 @@ AllCops:
   Exclude:
     - 'tmp/**/*'
     - 'examples/*'
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.6
 
-Metrics/LineLength:
+Layout/LineLength:
   Enabled: false
 
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: false
+
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: false
+
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: true
+
+Lint/DuplicateElsifCondition:
+  Enabled: false
+
+Lint/DuplicateRescueException:
+  Enabled: false
+
+Lint/EmptyConditionalBody:
+  Enabled: false
+
+Lint/FloatComparison:
+  Enabled: false
+
+Lint/MissingSuper:
+  Enabled: false
+
+Lint/OutOfRangeRegexpRef:
+  Enabled: false
+
+Lint/SelfAssignment:
+  Enabled: false
+
+Lint/TopLevelReturnWithArgument:
+  Enabled: false
+
+Lint/UnreachableLoop:
+  Enabled: false
+
+
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: false
+
+Lint/MixedRegexpCaptureTypes:
+  Enabled: false
+
+Lint/RaiseException:
+  Enabled: true
+
+Lint/StructNewOverride:
+  Enabled: true
+
+Style/AccessorGrouping:
+  Enabled: false
+
+Style/ArrayCoercion:
+  Enabled: false
+
+Style/BisectedAttrAccessor:
+  Enabled: true
+
+Style/CaseLikeIf:
+  Enabled: true
+
+Style/ExplicitBlockArgument:
+  Enabled: false
+
+Style/ExponentialNotation:
+  Enabled: true
+
+Style/GlobalStdStream:
+  Enabled: false
+
+Style/HashAsLastArrayItem:
+  Enabled: false
+
+Style/HashLikeCase:
+  Enabled: true
+
+Style/OptionalBooleanParameter:
+  Enabled: true
+
+Style/RedundantAssignment:
+  Enabled: true
+
+Style/RedundantFetchBlock:
+  Enabled: true
+
+Style/RedundantFileExtensionInRequire:
+  Enabled: true
+
+Style/SingleArgumentDig:
+  Enabled: true
+
+Style/StringConcatenation:
+  Enabled: true
+
+Style/RedundantRegexpCharacterClass:
+  Enabled: false
+
+Style/RedundantRegexpEscape:
+  Enabled: false
+
+Style/SlicingWithRange:
+  Enabled: true
+
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'
@@ -46,3 +149,12 @@ RSpec/DescribedClass:
 
 RSpec/ImplicitSubject:
   Enabled: false
+
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true

data/.sourcelevel.yml

@@ -0,0 +1,2 @@
+pull_requests:
+  comments: false

data/.travis.yml

@@ -6,7 +6,7 @@ env:
 rvm:
   - 2.6.3
 before_install:
-  gem install bundler -v 1.16.1
+  gem install bundler -v 2.1.4
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
   - chmod +x ./cc-test-reporter
@@ -14,5 +14,5 @@ before_script:
 after_script:
   - ./cc-test-reporter after-build -t simplecov --exit-code $TRAVIS_TEST_RESULT
 script:
-  - bundle exec rubocop
+  - bundle exec rubocop --fail-level warning --display-only-fail-level-offenses
   - bundle exec rspec

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

@@ -32,7 +32,7 @@ The current version of Fast covers the following token elements:
     to build custom rules.
 - `.<method-name>` - will call `<method-name>` from the `node`
 
-The syntax is inspired by the [RuboCop Node Pattern](https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb).
+The syntax is inspired by the [RuboCop Node Pattern](https://github.com/rubocop-hq/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb).
 
 ## Installation
 
@@ -253,25 +253,29 @@ This can be represented as the following AST:
 
 We can create a query that searches for such a method:
 
-    Fast.match?(ast,'(def $_ ... (send (send nil _) \1))') # => [:name]
+    Fast.match?('(def $_ ... (send (send nil _) \1))', ast) # => [:name]
 
 ## Fast.search
 
 Search allows you to go search the entire AST, collecting nodes that matches given
 expression. Any matching node is then returned:
 
-    Fast.search(Fast.ast('a = 1'), '(int _)') # => s(:int, 1)
+    Fast.search('(int _)', Fast.ast('a = 1')) # => s(:int, 1)
 
 If you use captures along with a search, both the matching nodes and the
 captures will be returned:
 
-    Fast.search(Fast.ast('a = 1'), '(int $_)') # => [s(:int, 1), 1]
+    Fast.search('(int $_)', Fast.ast('a = 1')) # => [s(:int, 1), 1]
+
+You can also bind external parameters from the search:
+
+    Fast.search('(int %1)', Fast.ast('a = 1'), 1) # => [s(:int, 1)]
 
 ## Fast.capture
 
 To only pick captures and ignore the nodes, use `Fast.capture`:
 
-  Fast.capture(Fast.ast('a = 1'), '(int $_)') # => 1
+  Fast.capture('(int $_)', Fast.ast('a = 1')) # => 1
 
 ## Fast.replace
 
@@ -421,6 +425,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/ideas.md

@@ -0,0 +1,80 @@
+# 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')"
+```

data/docs/index.md

@@ -269,6 +269,11 @@ If you use captures, it returns the node and the captures respectively:
 Fast.search('(int $_)', Fast.ast('a = 1')) # => [s(:int, 1), 1]
 ```
 
+You can also bind external parameters in the search using extra arguments:
+```ruby
+    Fast.search('(int %1)', Fast.ast('a = 1'), 1) # => [s(:int, 1)]
+```
+
 ## capture
 
 To pick just the captures and ignore the nodes, use `Fast.capture`:

data/docs/research.md

@@ -0,0 +1,93 @@
+
+# Research
+
+I love to research about codebase as data and prototyping ideas several times
+doesn't fit in simple [shortcuts](/shortcuts).
+
+Here is my first research that worth sharing:
+
+## Combining Runtime metadata with AST complex searches
+
+This example covers how to find RSpec `allow` combined with `and_return` missing
+the `with` clause specifying the nested parameters.
+
+Here is the [gist](https://gist.github.com/jonatas/c1e580dcb74e20d4f2df4632ceb084ef)
+if you want to go straight and run it.
+
+Scenario for simple example:
+
+Given I have the following class:
+
+```ruby
+class Account
+  def withdraw(value)
+    if @total >= value
+      @total -= value
+      :ok
+    else
+      :not_allowed
+    end
+  end
+end
+```
+
+And I'm testing it with `allow` and some possibilities:
+
+```ruby
+# bad
+allow(Account).to receive(:withdraw).and_return(:ok)
+# good
+allow(Account).to receive(:withdraw).with(100).and_return(:ok)
+```
+
+**Objective:** find all bad cases of **any** class that does not respect the method
+parameters signature.
+
+First, let's understand the method signature of a method:
+
+```ruby
+Account.instance_method(:withdraw).parameters
+# => [[:req, :value]]
+```
+
+Now, we can build a small script to use the node pattern to match the proper
+specs that are using such pattern and later visit their method signatures.
+
+
+```ruby
+Fast.class_eval do
+  # Captures class and method name when find syntax like:
+  # `allow(...).to receive(...)` that does not end with `.with(...)`
+  pattern_with_captures = <<~FAST
+  (send (send nil allow (const nil $_)) to
+    (send (send nil receive (sym $_)) !with))
+  FAST
+
+  pattern = expression(pattern_with_captures.tr('$',''))
+
+  ruby_files_from('spec').each do |file|
+    results = search_file(pattern, file) || [] rescue next
+    results.each do |n|
+      clazz, method = capture(n, pattern_with_captures)
+      if klazz = Object.const_get(clazz.to_s) rescue nil
+        if klazz.respond_to?(method)
+          params = klazz.method(method).parameters
+          if params.any?{|e|e.first == :req}
+            code = n.loc.expression
+            range = [code.first_line, code.last_line].uniq.join(",")
+            boom_message = "BOOM! #{clazz}.#{method} does not include the REQUIRED parameters!"
+            puts boom_message, "#{file}:#{range}", code.source
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+!!! hint "Preload your environment **before** run the script"
+
+    Keep in mind that you should run it with your environment preloaded otherwise it
+    will skip the classes.
+    You can add elses for `const_get` and `respond_to` and report weird cases if
+    your environment is not preloading properly.