pippi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b2991c3de0e47fb2502ca50193e9c6d1d1afef7
+  data.tar.gz: 16af3bb256083ed6f0b0f9faa2410e20110590a7
+SHA512:
+  metadata.gz: 320cd3c32751f7835f3b8213b5d51841f27400f564161b7a4e55d38db747cec4984f8d31c81c9ff63a5186f509d868407e87146210d37d620c2397db3f36b1c0
+  data.tar.gz: 44110d0bca80145d567821a6202562dac0f0757911feb983ff404932c87ad6843077ada711b37754c9bb9d4dca3e0dc268b4f7fc59dcd9ffe70033c8b15c773e

data/.gitignore

@@ -0,0 +1,5 @@
+tmp/
+pippi.log
+pippi_debug.log
+pippi*.gem
+out.txt

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.2

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+Oct 22, 2014 - 0.0.1:
+Initial release.
+
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    pippi (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (2.7.0)
+      columnize (~> 0.3)
+      debugger-linecache (~> 1.2)
+    columnize (0.8.9)
+    debugger-linecache (1.2.0)
+    minitest (5.4.2)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug (~> 2.7)
+  minitest (~> 5.0)
+  pippi!
+  rake (~> 10.1)

data/README.md

@@ -0,0 +1,177 @@
+Pippi is a utility for finding suboptimal Ruby class API usage.
+
+<a href="http://thomasleecopeland.com/2014/10/22/finding-suboptimal-api-usage.html">Here's a project overview.</a>.
+
+## Checks
+
+### MapFollowedByFlatten
+
+Don't use map followed by flatten; use flat_map instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].map {|x| [x,x+1] }.flatten
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].flat_map {|x| [x, x+1]}
+```
+
+### ReverseFollowedByEach
+
+Don't use each followed by reverse; use reverse_each instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].reverse.each {|x| x+1 }
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].reverse_each {|x| x+1 }
+```
+
+### SelectFollowedByFirst
+
+Don't use select followed by first; use detect instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].select {|x| x > 1 }.first
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].detect {|x| x > 1 }
+```
+
+### SelectFollowedBySize
+
+Don't use select followed by size; use count instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].select {|x| x > 1 }.size
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].count {|x| x > 1 }
+```
+
+## Usage
+
+### Inside Rails tests
+
+See https://github.com/tcopeland/pippi_demo#pippi-demo
+
+### From the command line:
+
+Assuming you're using bundler:
+
+```bash
+# Add this to your project's Gemfile:
+gem 'pippi'
+# Run 'bundle', see some output
+# To run a particular check:
+bundle exec pippi tmp/tmpfile.rb MapFollowedByFlatten Foo.new.bar out.txt
+# Or to run all the basic Pippi checks on your code and exercise it with MyClass.new.exercise_some_code:
+bundle exec ruby -rpippi/auto_runner -e "MyClass.new.exercise_some_code"
+```
+
+## Ideas for other problems to detect:
+
+```ruby
+# Don't use select followed by compact, use select with the nil inside the block
+# Use assert_nil rather than assert_equals
+# wrong
+assert_equals(nil, foo)
+# right
+assert_nil foo
+
+# unnecessary assignment since String#strip! mutates receiver
+# wrong
+x = x.strip!
+# right
+x.strip!
+
+# Use Pathname
+# wrong
+File.read(File.join(Rails.root, "config", "database.yml")
+# right
+Rails.root.join("config", "database.yml").read
+
+# Use Kernel#tap
+# wrong
+x = [1,2]
+x << 3
+return x
+# right
+[1,2].tap {|y| y << 3 }
+
+
+# Rails checks
+
+# No need to call to_i on ActiveRecord::Base methods passed to route generators
+# wrong
+product_path(@product.to_i)
+# right
+product_path(@product)
+
+# something with replacing x.map.compact with x.select.map
+````
+
+## Here are some things that Pippi is not well suited for
+### Use self.new vs MyClass.new.  This is not a good fit for Pippi because it involves a receiver usage that can be detected with static analysis.
+#### wrong
+class Foo
+  def self.bar
+    Foo.new
+  end
+end
+#### right
+class Foo
+  def self.bar
+    self.new
+  end
+end
+
+
+## TODO
+
+* Clean up this initial hacked out metaprogramming
+* Do more checks
+* Make writing rules nicer, without some much dorking around with methods.  "select followed by first" could be specified with something like "Array#select => #first" and the rest left up to the framework.
+
+## Developing
+
+To see teacher output for a file `tmp/baz.rb`:
+
+```bash
+rm -f pippi_debug.log ; PIPPI_DEBUG=1 bundle exec pippi tmp/baz.rb DebugCheck Foo.new.bar tmp/out.txt ; cat pippi_debug.log
+```
+
+When trying to find issues in a project:
+
+```bash
+# in project directory (e.g., aasm)
+rm -rf pippi_debug.log pippi.log .bundle/gems/pippi-0.0.1/ .bundle/cache/pippi-0.0.1.gem .bundle/specifications/pippi-0.0.1.gemspec && bundle update pippi --local && PIPPI_DEBUG=1 bundle exec ruby -rpippi/auto_runner -e "puts 'hi'" && grep -C 5 BOOM pippi_debug.log
+# or to run some specs with pippi watching:
+rm -rf pippi_debug.log pippi.log .bundle/gems/pippi-0.0.1/ .bundle/cache/pippi-0.0.1.gem .bundle/specifications/pippi-0.0.1.gemspec && bundle update pippi --local && PIPPI_DEBUG=1 bundle exec ruby -rpippi/auto_runner -Ispec spec/unit/*.rb
+
+```
+
+## Credits
+
+* Thanks to <a href="https://www.livingsocial.com/">LivingSocial</a> for letting me develop and open source this utility.
+* Thanks to Evan Phoenix for the idea of watching method invocations at runtime using metaprogramming rather than using `Tracepoint`.
+* Thanks to Michael Bernstein (of Code Climate fame) for an inspirational discussion of code anaysis in general.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+require 'rubygems'
+require 'bundler/setup'
+require 'pippi/tasks'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/unit/**_test.rb"
+end
+
+task :default => [:test]

data/bin/pippi

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'pippi'
+
+Pippi::ExecRunner.new(ARGV.dup).run

data/doc/README

@@ -0,0 +1 @@
+Docs

data/doc/docs.md

@@ -0,0 +1,64 @@
+
+### MapFollowedByFlatten
+
+Don't use map followed by flatten; use flat_map instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].map {|x| [x,x+1] }.flatten
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].flat_map {|x| [x, x+1]}
+```
+
+### ReverseFollowedByEach
+
+Don't use each followed by reverse; use reverse_each instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].reverse.each {|x| x+1 }
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].reverse_each {|x| x+1 }
+```
+
+### SelectFollowedByFirst
+
+Don't use select followed by first; use detect instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].select {|x| x > 1 }.first
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].detect {|x| x > 1 }
+```
+
+### SelectFollowedBySize
+
+Don't use select followed by size; use count instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].select {|x| x > 1 }.size
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].count {|x| x > 1 }
+```

data/lib/pippi.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+
+require 'pippi/context'
+require 'pippi/check_set_mapper'
+require 'pippi/report'
+require "pippi/checks/check"
+require 'pippi/problem'
+require 'pippi/check_loader'
+require 'pippi/exec_runner'
+require 'pippi/auto_runner'
+require 'pippi/checks/map_followed_by_flatten'
+require 'pippi/checks/reverse_followed_by_each'
+require 'pippi/checks/select_followed_by_first'
+require 'pippi/checks/select_followed_by_size'
+require 'pippi/checks/debug_check'

data/lib/pippi/auto_runner.rb

@@ -0,0 +1,24 @@
+module Pippi
+
+  class AutoRunner
+    attr_reader :ctx
+
+    def initialize(opts={})
+      checkset = opts.fetch(:checkset, "basic")
+      @ctx = Pippi::Context.new
+      Pippi::CheckLoader.new(@ctx, checkset).checks.each(&:decorate)
+      at_exit { dump }
+    end
+
+    def dump
+      File.open("log/pippi.log", "w") do |outfile|
+        @ctx.report.problems.each do |problem|
+          outfile.syswrite("#{problem.to_text}\n")
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/pippi/check_loader.rb

@@ -0,0 +1,23 @@
+module Pippi
+
+  class CheckLoader
+
+    attr_reader :ctx, :check_names
+
+    def initialize(ctx, check_names)
+      @ctx = ctx
+      @check_names = if check_names.kind_of?(String)
+        Pippi::CheckSetMapper.new(check_names).check_names
+      else
+        check_names
+      end
+    end
+
+    def checks
+      check_names.map do |check_name|
+        Pippi::Checks.const_get(check_name).new(ctx)
+      end
+    end
+
+  end
+end

data/lib/pippi/check_set_mapper.rb

@@ -0,0 +1,35 @@
+module Pippi
+
+  class CheckSetMapper
+
+    attr_reader :raw_check_specifier
+
+    def initialize(raw_check_specifier)
+      @raw_check_specifier = raw_check_specifier
+    end
+
+    def check_names
+      raw_check_specifier.split(",").map do |specifier|
+        predefined_sets[specifier] || specifier
+      end.flatten
+    end
+
+    private
+
+    def predefined_sets
+      {
+        "basic" => [
+          "SelectFollowedByFirst",
+          "SelectFollowedBySize",
+          "ReverseFollowedByEach",
+        ],
+        "training" => [
+        ],
+        "buggy" => [
+          "MapFollowedByFlatten",
+        ]
+      }
+    end
+
+  end
+end

data/lib/pippi/checks/check.rb

@@ -0,0 +1,39 @@
+module Pippi::Checks
+
+  class Check
+
+    attr_accessor :ctx
+
+    def initialize(ctx)
+      @ctx = ctx
+    end
+
+    def array_mutator_methods
+      [:collect!, :compact!, :flatten!, :map!, :reject!, :reverse!, :rotate!, :select!, :shuffle!, :slice!, :sort!, :sort_by!, :uniq!]
+    end
+
+    def add_problem
+      problem_location = caller_locations.detect {|c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
+      ctx.report.add(Pippi::Problem.new(:line_number => problem_location.lineno, :file_path => problem_location.path, :check_class => self.class))
+    end
+
+    def clear_fault_proc
+      Proc.new do
+        problem_location = caller_locations.detect {|c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
+        self.class._pippi_check_select_followed_by_size.clear_fault(problem_location.lineno, problem_location.path)
+      end
+    end
+
+    def clear_fault(lineno, path)
+      ctx.report.remove(lineno, path, self.class)
+    end
+
+    def its_ok_watcher_proc(clazz, method_name)
+      Proc.new do
+        singleton_class.ancestors.detect {|x| x == clazz }.instance_eval { remove_method method_name }
+        super()
+      end
+    end
+
+  end
+end