pippi 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ad992cb9bc5aa2b1e2ea7ee7acbe531cbb2432e
-  data.tar.gz: 564a5feffa9d49e8eb28d878f4635c93ba19921e
+  metadata.gz: c05baba246fbeb0947f998387800ef5e59bea9d0
+  data.tar.gz: 88364a935624811ace53ee739bf5f7bde545ad0e
 SHA512:
-  metadata.gz: 9e1046f43ec28739b33a224136a3c852ea9a0c91579f5c22bff9f102e0fff483bb0ce9c97a9b93d2cb34d4a1c6fca390bfff9de1ec2020488d96d7ff6d88faec
-  data.tar.gz: 822431d1b25e296483f2031a8ec581788615e6c1d89b02b9fee1fd4474172c72e8b753cbcaaae81f1e51564cc881a6ae38a7dd92ff3dfa5ec9dad96bb15f5879
+  metadata.gz: 8d7e3c193f1d5c74835b4eaf2e94cb5c4038a2a202ce7b89febeab9f7529ee8db5a6f49acd89f77578e16772846321898fb777502104064a72596232cbf5bbda
+  data.tar.gz: 4fa3c78158aa1469e4354e97826ccf4cba4cd41d560dfd7ca24bc00783d174d78417bd236161f1e0573eee081b798b8022ee0981ffbf967aa58592f3142d7c50

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.0.11 (2014-12-19)
+
+* [NEW] More logging options
+
 ## 0.0.10 (2014-12-09)
 
 * [NEW] Added SelectFollowedByNone

data/README.md

@@ -49,7 +49,7 @@ Here's how pippi stacks up using the [Aaron Quint](https://twitter.com/aq) [Ruby
 * Realtimedness - finds stuff right away
 * Special Abilities - ?
 
-Finally, why "pippi"? Because Pippi Longstocking was a Thing-Finder, and pippi finds things.
+Finally, why "pippi"? Because Pippi Longstocking was a <a href="http://www.laredoisd.org/cdbooks/NOVELS/Pippi%20Longstocking/CH02.txt">Thing-Finder</a>, and pippi finds things.
 
 ## Usage
 
@@ -61,6 +61,8 @@ Finally, why "pippi"? Because Pippi Longstocking was a Thing-Finder, and pippi f
 ```ruby
 if ENV['USE_PIPPI'].present?
   Pippi::AutoRunner.new(:checkset => ENV['PIPPI_CHECKSET'] || "basic")
+  # you can also pass in an IO:
+  # Pippi::AutoRunner.new(:checkset => "basic", :io => $stdout)
 end
 ```
 * Run it:
@@ -373,6 +375,7 @@ rm -rf pippi_debug.log pippi.log .bundle/gems/pippi-0.0.1/ .bundle/cache/pippi-0
 * [Evan Phoenix](https://twitter.com/evanphx)([@evanphx](https://github.com/evanphx)) for the idea of watching method invocations at runtime using metaprogramming rather than using `Tracepoint`.
 * Hubert Dąbrowski: Ruby 2.0.0 fixes
 * [Igor Kapkov](https://twitter.com/igasgeek)([@igas](https://github.com/igas)) documentation fixes
+* [Josh Bodah](https://github.com/jbodah): Better logging support
 * [LivingSocial](https://www.livingsocial.com/) for letting me develop and open source this utility.
 * [Michael Bernstein](https://twitter.com/mrb_bk)([@mrb](https://github.com/mrb)) (of [CodeClimate](https://codeclimate.com/) fame) for an inspirational discussion of code anaysis in general.
 * [Olle Jonsson](https://twitter.com/olleolleolle)([@olleolleolle](https://github.com/olleolleolle)) rubocop fixes

data/lib/pippi/auto_runner.rb

@@ -4,6 +4,7 @@ module Pippi
 
     def initialize(opts = {})
       checkset = opts.fetch(:checkset, 'basic')
+      @io = opts.fetch(:io, File.open('log/pippi.log', 'w'))
       @ctx = Pippi::Context.new
 
       @ctx.checks = Pippi::CheckLoader.new(@ctx, checkset).checks
@@ -15,10 +16,8 @@ module Pippi
       if @ctx.checks.one? && @ctx.checks.first.kind_of?(Pippi::Checks::MethodSequenceFinder)
         @ctx.checks.first.dump
       end
-      File.open('log/pippi.log', 'w') do |outfile|
-        @ctx.report.problems.each do |problem|
-          outfile.syswrite("#{problem.to_text}\n")
-        end
+      @ctx.report.problems.each do |problem|
+        @io.puts(problem.to_text)
       end
     end
   end

data/lib/pippi/checks/method_sequence_checker.rb

@@ -24,24 +24,31 @@ class MethodSequenceChecker
       end
 
       # e.g., "size" in "select followed by size"
-      second_method_decorator = Module.new do
-        define_method(method_sequence_check_instance.method2) do |*args, &blk|
-          self.class.instance_variable_get(name).add_problem
-          if method_sequence_check_instance.should_check_subsequent_calls && method_sequence_check_instance.clazz_to_decorate == Array
-            problem_location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
-            self.class.instance_variable_get(name).method_names_that_indicate_this_is_being_used_as_a_collection.each do |this_means_its_ok_sym|
-              define_singleton_method(this_means_its_ok_sym, self.class.instance_variable_get(name).clear_fault_proc(self.class.instance_variable_get(name), problem_location))
+      second_method_decorator = if method_sequence_check_instance.second_method_arity_type.kind_of?(Module)
+        method_sequence_check_instance.second_method_arity_type
+      else
+        Module.new do
+          define_method(method_sequence_check_instance.method2) do |*args, &blk|
+            # Using "self.class" implies that the first method invocation returns the same type as the receiver
+            # e.g., Array#select returns an Array.  Would need to further parameterize this to get
+            # different behavior.
+            self.class.instance_variable_get(name).add_problem
+            if method_sequence_check_instance.should_check_subsequent_calls && method_sequence_check_instance.clazz_to_decorate == Array
+              problem_location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
+              self.class.instance_variable_get(name).method_names_that_indicate_this_is_being_used_as_a_collection.each do |this_means_its_ok_sym|
+                define_singleton_method(this_means_its_ok_sym, self.class.instance_variable_get(name).clear_fault_proc(self.class.instance_variable_get(name), problem_location))
+              end
+            end
+            if method_sequence_check_instance.second_method_arity_type == ARITY_TYPE_BLOCK_ARG
+              super(&blk)
+            elsif method_sequence_check_instance.second_method_arity_type == ARITY_TYPE_NONE
+              super()
             end
-          end
-          if method_sequence_check_instance.second_method_arity_type == ARITY_TYPE_BLOCK_ARG
-            super(&blk)
-          elsif method_sequence_check_instance.second_method_arity_type == ARITY_TYPE_NONE
-            super()
           end
         end
       end
 
-      # e.g., "select" in "select followed ARITY_TYPE_NONEze"
+      # e.g., "select" in "select followed by size"
      first_method_decorator = Module.new do
         define_method(method_sequence_check_instance.method1) do |*args, &blk|
           result = if method_sequence_check_instance.first_method_arity_type == ARITY_TYPE_BLOCK_ARG

data/lib/pippi/checks/method_sequence_finder.rb

@@ -1,10 +1,10 @@
 module Pippi::Checks
 
   module MyModule
-    def split(&blk)
+    def strip(*args, &blk)
       result = super
       if self.class._pippi_method_call_sequences
-        array_methods_to_track.each do |track_this|
+        self.class._pippi_method_call_sequences.methods_to_track.each do |track_this|
           result.define_singleton_method(track_this, track_it_proc(track_this))
         end
       end
@@ -23,18 +23,15 @@ module Pippi::Checks
         end
       end
     end
-    
-    def string_methods_to_track
-      [:ascii_only?, :b, :between?, :bytes, :bytesize, :byteslice, :capitalize, :capitalize!, :casecmp, :center, :chars, :chomp, :chomp!, :chop, :chop!, :chr, :clear, :codepoints, :concat, :count, :crypt, :delete, :delete!, :downcase, :downcase!, :dump, :each_byte, :each_char, :each_codepoint, :each_line, :empty?, :encode, :encode!, :encoding, :end_with?, :force_encoding, :getbyte, :gsub, :gsub!, :hex, :index, :insert, :intern, :length, :lines, :ljust, :lstrip, :lstrip!, :match, :next, :next!, :oct, :ord, :partition, :replace, :reverse, :reverse!, :rindex, :rjust, :rpartition, :rstrip, :rstrip!, :scan, :scrub, :scrub!, :setbyte, :size, :slice, :slice!, :split, :squeeze, :squeeze!, :start_with?, :strip, :strip!, :sub, :sub!, :succ, :succ!, :sum, :swapcase, :swapcase!, :to_c, :to_f, :to_i, :to_r, :to_str, :to_sym, :tr, :tr!, :tr_s, :tr_s!, :unpack, :upcase, :upcase!, :upto, :valid_encoding?]      
-    end
 
-    def array_methods_to_track
-      [:all?, :any?, :assoc, :at, :bsearch, :chunk, :clear, :collect, :collect!, :collect_concat, :combination, :compact, :compact!, :concat, :count, :cycle, :delete, :delete_at, :delete_if, :detect, :drop, :drop_while, :each, :each_cons, :each_entry, :each_index, :each_slice, :each_with_index, :each_with_object, :empty?, :entries, :fetch, :fill, :find, :find_all, :find_index, :first, :flat_map, :flatten, :flatten!, :grep, :group_by, :histogram, :index, :inject, :insert, :join, :keep_if, :last, :lazy, :length, :map, :map!, :max, :max_by, :member?, :min, :min_by, :minmax, :minmax_by, :none?, :one?, :pack, :partition, :permutation, :pop, :product, :push, :rassoc, :reduce, :reject, :reject!, :repeated_combination, :repeated_permutation, :replace, :reverse, :reverse!, :reverse_each, :rindex, :rotate, :rotate!, :sample, :select, :select!, :shift, :shuffle, :shuffle!, :size, :slice, :slice!, :slice_before, :sort, :sort!, :sort_by, :sort_by!, :take, :take_while, :to_a, :to_ary, :to_h, :transpose, :uniq, :uniq!, :unshift, :values_at, :zip]
-    end
   end
 
   class MethodSequenceFinder < Check
 
+    STRING_METHODS_TO_TRACK = [:ascii_only?, :b, :between?, :bytes, :bytesize, :byteslice, :capitalize, :capitalize!, :casecmp, :center, :chars, :chomp, :chomp!, :chop, :chop!, :chr, :clear, :codepoints, :concat, :count, :crypt, :delete, :delete!, :downcase, :downcase!, :dump, :each_byte, :each_char, :each_codepoint, :each_line, :empty?, :encode, :encode!, :encoding, :end_with?, :force_encoding, :getbyte, :gsub, :gsub!, :hex, :index, :insert, :intern, :length, :lines, :ljust, :lstrip, :lstrip!, :match, :next, :next!, :oct, :ord, :partition, :replace, :reverse, :reverse!, :rindex, :rjust, :rpartition, :rstrip, :rstrip!, :scan, :scrub, :scrub!, :setbyte, :size, :slice, :slice!, :split, :squeeze, :squeeze!, :start_with?, :strip, :strip!, :sub, :sub!, :succ, :succ!, :sum, :swapcase, :swapcase!, :to_c, :to_f, :to_i, :to_r, :to_str, :to_sym, :tr, :tr!, :tr_s, :tr_s!, :unpack, :upcase, :upcase!, :upto, :valid_encoding?]
+
+    ARRAY_METHODS_TO_TRACK = [:all?, :any?, :assoc, :at, :bsearch, :chunk, :clear, :collect, :collect!, :collect_concat, :combination, :compact, :compact!, :concat, :count, :cycle, :delete, :delete_at, :delete_if, :detect, :drop, :drop_while, :each, :each_cons, :each_entry, :each_index, :each_slice, :each_with_index, :each_with_object, :empty?, :entries, :fetch, :fill, :find, :find_all, :find_index, :first, :flat_map, :flatten, :flatten!, :grep, :group_by, :histogram, :index, :inject, :insert, :join, :keep_if, :last, :lazy, :length, :map, :map!, :max, :max_by, :member?, :min, :min_by, :minmax, :minmax_by, :none?, :one?, :pack, :partition, :permutation, :pop, :product, :push, :rassoc, :reduce, :reject, :reject!, :repeated_combination, :repeated_permutation, :replace, :reverse, :reverse!, :reverse_each, :rindex, :rotate, :rotate!, :sample, :select, :select!, :shift, :shuffle, :shuffle!, :size, :slice, :slice!, :slice_before, :sort, :sort!, :sort_by, :sort_by!, :take, :take_while, :to_a, :to_ary, :to_h, :transpose, :uniq, :uniq!, :unshift, :values_at, :zip]
+
     class Record
       attr_reader :path, :lineno, :meth1, :meth2
       def initialize(path, lineno, meth1, meth2)
@@ -52,22 +49,43 @@ module Pippi::Checks
       end
     end
 
-    attr_reader :sequences, :clazz_to_decorate
+    attr_reader :sequences, :clazz_to_decorate, :starting_method
+
+=begin
+To add a new sequence finder where the first method is on String, change the starting_method below
+and also change the method name up in MyModule.  To change it to a different class you must also
+change :clazz_to_decorate
 
+=end
     def initialize(ctx)
       super
       @clazz_to_decorate = String
+      @starting_method = "strip"
+
       @sequences = Set.new
     end
 
+    def methods_to_track
+      if clazz_to_decorate == String
+        STRING_METHODS_TO_TRACK
+      elsif clazz_to_decorate == Array
+        ARRAY_METHODS_TO_TRACK
+      else
+        raise "Unhandled class #{clazz_to_decorate}"
+      end
+    end
+
     def dump
       @sequences.map {|r| "#{r.meth1}:#{r.meth2}" }.inject({}) {|m,i| m[i] ||= 0 ;  m[i] += 1  ; m }.to_a.sort_by {|x| x[1] }.reverse.each do |r|
         puts "#{r[0].split(':')[0]} followed by #{r[0].split(':')[1]} occurred #{r[1]} times\n"
+        @sequences.select {|s| (s.meth1 == r[0].split(':')[0]) && (s.meth2 == r[0].split(':')[1].to_sym) }.each do |s|
+          puts "#{s.path}: #{s.lineno}"
+        end
       end
     end
 
     def found_sequence(method_name, location)
-      @sequences << Record.new(location.path, location.lineno, "map", method_name)
+      @sequences << Record.new(location.path, location.lineno, starting_method, method_name)
     end
 
     def decorate

data/lib/pippi/checks/select_followed_by_first.rb

@@ -1,11 +1,10 @@
 module Pippi::Checks
   class SelectFollowedByFirst < Check
 
-    # TODO make this use MethodSequenceChecker
-    module MyFirst
+    module MyModule
       def first(elements = nil)
         unless elements
-          self.class._pippi_check_select_followed_by_first.add_problem
+          self.class._pippi_check_selectfollowedbyfirst.add_problem
         end
         if elements
           super(elements)
@@ -15,29 +14,13 @@ module Pippi::Checks
       end
     end
 
-    module MySelect
-      def select(&blk)
-        result = super
-        if self.class._pippi_check_select_followed_by_first.nil?
-          # Ignore Array subclasses since select or first may have difference meanings
-        else
-          result.extend MyFirst
-          self.class._pippi_check_select_followed_by_first.array_mutator_methods.each do |this_means_its_ok_sym|
-            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_first.its_ok_watcher_proc(MyFirst, :first))
-          end
-        end
-        result
-      end
+    def decorate
+      @mycheck.decorate
     end
 
-    def decorate
-      Array.class_exec(self) do |my_check|
-        @_pippi_check_select_followed_by_first = my_check
-        class << self
-          attr_reader :_pippi_check_select_followed_by_first
-        end
-        prepend MySelect
-      end
+    def initialize(ctx)
+      super
+      @mycheck = MethodSequenceChecker.new(self, Array, "select", "first", MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, MyModule, true)
     end
 
     class Documentation

data/lib/pippi/version.rb

@@ -1,3 +1,3 @@
 module Pippi
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pippi
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Tom Copeland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2014-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake