fasterer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 700f1de5e4957667423d3e045970c1046e86579f
+  data.tar.gz: 7c60c88efa59abe5857436f1a229a96b54f77e6d
+SHA512:
+  metadata.gz: 70b4baaf83af7c16e926245b5685b9a2b52568f4f81c279da6d0f70a68cd1af49b82dda342c43d0a4f5c4e6bb65ab027cb9fee19afdd0601be6815db660d2865
+  data.tar.gz: 26543c720eefaf8f678e4353d4a5837d336912def1359d300a3d3f45903ca1bf4e2185446e916ef9fdf4b74c4548e829989f1d2f9131f1438cd6180141435565

data/.fasterer.yml

@@ -0,0 +1,17 @@
+speedups:
+  parallel_assignment: false
+  rescue_vs_respond_to: true
+  module_eval: true
+  shuffle_first_vs_sample: true
+  for_loop_vs_each: true
+  each_with_index_vs_while: false
+  map_flatten_vs_flat_map: true
+  reverse_each_vs_reverse_each: true
+  select_first_vs_detect: true
+  sort_vs_sort_by: true
+  fetch_with_argument_vs_block: true
+  keys_each_vs_each_key: true
+  hash_merge_bang_vs_hash_brackets: true
+  block_vs_symbol_to_proc: true
+  proc_call_vs_yield: true
+  gsub_vs_tr: true

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  Include:
+    - '**/Rakefile'
+  Exclude:
+    - 'spec/support/**/*'
+    - 'spec/spec_helper.rb'
+Documentation:
+    Enabled: false

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fasterer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Damir Svrtan
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+[![Build Status](https://travis-ci.org/DamirSvrtan/fasterer.svg?branch=master)](https://travis-ci.org/DamirSvrtan/fasterer)
+[![Code Climate](https://codeclimate.com/github/DamirSvrtan/fasterer/badges/gpa.svg)](https://codeclimate.com/github/DamirSvrtan/fasterer)
+# Fasterer
+
+Make your Rubies go faster with this command line tool highly inspired by [fast-ruby](https://github.com/JuanitoFatas/fast-ruby) and [Sferik's talk at Baruco Conf](https://speakerdeck.com/sferik/writing-fast-ruby).
+
+Fasterer will suggest some speed improvements which you can check in detail at the [fast-ruby repo](https://github.com/JuanitoFatas/fast-ruby).
+
+**Please note** that you shouldn't follow the suggestions blindly. Using a while loop instead of a each_with_index probably shouldn't be considered if you're doing a regular Rails project, but maybe if you're doing something very speed dependent such as Rack or if you're building your own framework, you might consider this speed increase.
+
+
+
+## Installation
+
+```shell
+gem install fasterer
+```
+
+## Usage
+
+Run it from the root of your project:
+
+```shell
+fasterer
+```
+
+## Example output
+
+```shell
+
+app/models/post.rb
+Array#select.first is slower than Array#detect. Occured at lines: 57, 61.
+
+db/seeds/cities.rb
+Hash#keys.each is slower than Hash#each_key. Occured at lines: 15, 33.
+
+test/options_test.rb
+Hash#merge! with one argument is slower than Hash#[]. Occured at lines: 84.
+
+test/module_test.rb
+Don't rescue NoMethodError, rather check with respond_to?. Occured at lines: 272.
+
+spec/cache/mem_cache_store_spec.rb
+Use tr instead of gsub when grepping plain strings. Occured at lines: 161.
+```
+## Configuration
+
+You can turn of speed suggestions with a simple yaml file called **.fasterer.yml** in the root of your project. Example:
+
+
+```yaml
+speedups:
+  parallel_assignment: false
+  rescue_vs_respond_to: true
+  module_eval: true
+  shuffle_first_vs_sample: true
+  for_loop_vs_each: true
+  each_with_index_vs_while: false
+  map_flatten_vs_flat_map: true
+  reverse_each_vs_reverse_each: true
+  select_first_vs_detect: true
+  sort_vs_sort_by: true
+  fetch_with_argument_vs_block: true
+  keys_each_vs_each_key: true
+  hash_merge_bang_vs_hash_brackets: true
+  block_vs_symbol_to_proc: true
+  proc_call_vs_yield: true
+  gsub_vs_tr: true
+```
+
+## TODOs:
+
+4. find vs bsearch
+5. Array#count vs Array#size
+7. Enumerable#each + push vs Enumerable#map
+17. Hash#merge vs Hash#merge!
+20. String#casecmp vs String#downcase + ==
+21. String concatenation
+22. String#match vs String#start_with?/String#end_with?
+23. String#gsub vs String#sub
+
+# New
+
+values each -> each_value
+class_eval
+
+## Contributing
+
+1. Fork it ( https://github.com/DamirSvrtan/fasterer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Run all RSpec tests'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/fasterer

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'fasterer/cli'
+
+Fasterer::CLI.execute

data/fasterer.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fasterer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fasterer'
+  spec.version       = Fasterer::VERSION
+  spec.authors       = ['Damir Svrtan']
+  spec.email         = ['damir.svrtan@gmail.com']
+  spec.summary       = 'Run Ruby more than fast. Fasterer'
+  spec.description   = 'Use Fasterer to check various places in your code that could be faster.'
+  spec.homepage      = 'https://github.com/DamirSvrtan/fasterer'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'colorize', '~> 0.7'
+  spec.add_dependency 'ruby_parser', '~> 3.6'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake',    '~> 10.0'
+  spec.add_development_dependency 'rspec',   '~> 3.1'
+  spec.add_development_dependency 'pry',     '~> 0.10'
+end

data/lib/fasterer.rb

@@ -0,0 +1,7 @@
+require 'fasterer/version'
+require 'fasterer/analyzer'
+require 'fasterer/method_definition'
+
+module Fasterer
+  # Your code goes here...
+end

data/lib/fasterer/analyzer.rb

@@ -0,0 +1,99 @@
+require 'fasterer/method_definition'
+require 'fasterer/method_call'
+require 'fasterer/rescue_call'
+require 'fasterer/offense_collector'
+require 'fasterer/parser'
+require 'fasterer/parse_error'
+require 'fasterer/scanners/method_call_scanner'
+require 'fasterer/scanners/rescue_call_scanner'
+require 'fasterer/scanners/method_definition_scanner'
+
+module Fasterer
+  class Analyzer
+    attr_reader :file_path
+    alias_method :path, :file_path
+
+    def initialize(file_path)
+      @file_path = file_path
+      @file_content = File.read(file_path)
+    end
+
+    def scan
+      sexp_tree = Fasterer::Parser.parse(@file_content)
+      fail ParseError.new(file_path) if sexp_tree.nil?
+      traverse_sexp_tree(sexp_tree)
+    end
+
+    def errors
+      @errors ||= Fasterer::OffenseCollector.new
+    end
+
+    private
+
+    def traverse_sexp_tree(sexp_tree)
+      return unless sexp_tree.is_a?(Sexp)
+
+      token = sexp_tree.first
+
+      scan_by_token(token, sexp_tree)
+
+      case token
+      when :call, :iter
+        method_call = MethodCall.new(sexp_tree)
+        traverse_sexp_tree(method_call.receiver_element) if method_call.receiver_element
+        traverse_sexp_tree(method_call.arguments_element)
+        traverse_sexp_tree(method_call.block_body) if method_call.has_block?
+      else
+        sexp_tree.each { |element| traverse_sexp_tree(element) }
+      end
+    end
+
+    def scan_by_token(token, element)
+      case token
+      when :defn
+        scan_method_definitions(element)
+      when :call, :iter
+        scan_method_calls(element)
+      when :masgn
+        scan_parallel_assignment(element)
+      when :for
+        scan_for_loop(element)
+      when :resbody
+        scan_rescue(element)
+      end
+    end
+
+    def scan_method_definitions(element)
+      method_definition_scanner = MethodDefinitionScanner.new(element)
+
+      if method_definition_scanner.offense_detected?
+        errors.push(method_definition_scanner.offense)
+      end
+    end
+
+    def scan_method_calls(element)
+      method_call_scanner = MethodCallScanner.new(element)
+
+      if method_call_scanner.offense_detected?
+        errors.push(method_call_scanner.offense)
+      end
+    end
+
+    def scan_parallel_assignment(element)
+      errors.push(Fasterer::Offense.new(:parallel_assignment, element.line))
+    end
+
+    def scan_for_loop(element)
+      errors.push(Fasterer::Offense.new(:for_loop_vs_each, element.line))
+    end
+
+    def scan_rescue(element)
+      rescue_call_scanner = RescueCallScanner.new(element)
+
+      if rescue_call_scanner.offense_detected?
+        errors.push(rescue_call_scanner.offense)
+      end
+    end
+
+  end
+end

data/lib/fasterer/binary_call.rb

@@ -0,0 +1,4 @@
+module Fasterer
+  class BinaryCall
+  end
+end

data/lib/fasterer/cli.rb

@@ -0,0 +1,10 @@
+require_relative 'file_traverser'
+
+module Fasterer
+  class CLI
+    def self.execute
+      file_traverser = Fasterer::FileTraverser.new('.')
+      file_traverser.traverse
+    end
+  end
+end

data/lib/fasterer/file_traverser.rb

@@ -0,0 +1,81 @@
+require 'pathname'
+require 'colorize'
+require 'yaml'
+
+require_relative 'analyzer'
+
+module Fasterer
+  class FileTraverser
+
+    CONFIG_FILE_NAME = '.fasterer.yml'
+
+    attr_reader :ignored_speedups
+
+    def initialize(path)
+      @path = Pathname(path)
+      @parse_error_paths = []
+      set_ignored_speedups
+    end
+
+    def traverse
+      if @path.directory?
+        traverse_directory(@path)
+      else
+        scan_file(@path)
+      end
+      output_parse_errors if parse_error_paths.any?
+    end
+
+    def set_ignored_speedups
+      @ignored_speedups = if config_file
+        config_file['speedups'].select {|_, value| value == false }.keys.map(&:to_sym)
+      end || []
+    end
+
+    def config_file
+      File.exists?(CONFIG_FILE_NAME) && YAML.load_file(CONFIG_FILE_NAME)
+    end
+
+    private
+
+    attr_reader :parse_error_paths
+
+    def scan_file(path)
+      analyzer = Analyzer.new(path)
+      analyzer.scan
+    rescue Fasterer::ParseError, RubyParser::SyntaxError, Racc::ParseError
+      parse_error_paths.push(path)
+    else
+      output(analyzer) if offenses_grouped_by_type(analyzer).any?
+    end
+
+    def traverse_directory(path)
+      Dir["#{path}/**/*.rb"].each do |ruby_file|
+        scan_file(ruby_file.split('/').drop(1).join('/'))
+      end
+    end
+
+    def output(analyzer)
+      puts analyzer.file_path.colorize(:red)
+
+      offenses_grouped_by_type(analyzer).each do |error_group_name, error_occurences|
+        puts "#{Fasterer::Offense::EXPLANATIONS[error_group_name]}. Occured at lines: #{error_occurences.map(&:line_number).join(', ')}."
+      end
+
+      puts
+    end
+
+    def offenses_grouped_by_type(analyzer)
+      analyzer.errors.group_by(&:name).delete_if {|offense_name, _| ignored_speedups.include?(offense_name) }
+    end
+
+    def output_parse_errors
+      puts 'Fasterer was unable to process some files because the'
+      puts 'internal parser is not able to read some characters.'
+      puts 'Unprocessable files were:'
+      puts '-----------------------------------------------------'
+      puts parse_error_paths
+      puts
+    end
+  end
+end