pippi 0.0.1

data/lib/pippi/checks/debug_check.rb

@@ -0,0 +1,14 @@
+module Pippi::Checks
+
+  class DebugCheck < Check
+
+    ["line", "class", "end", "call", "return", "c_call", "c_return", "b_call", "b_return", "raise", "thread_begin", "thread_end"].each do |event_name|
+      define_method "#{event_name}_event" do |tp|
+        return if tp.path =~ %r{lib/pippi}
+        ctx.debug_logger.warn "#{event_name}_event in #{tp.defined_class}##{tp.method_id} at line #{tp.lineno} of #{tp.path}"
+        ctx.debug_logger.warn "  return_value #{tp.return_value}" rescue nil
+      end
+    end
+
+  end
+end

data/lib/pippi/checks/map_followed_by_flatten.rb

@@ -0,0 +1,55 @@
+module Pippi::Checks
+
+  class MapFollowedByFlatten < Check
+
+    module MyFlatten
+      def flatten(depth=nil)
+        result = super(depth)
+        if depth && depth == 1
+          self.class._pippi_check_map_followed_by_flatten.add_problem
+        end
+        result
+      end
+    end
+
+    module MyMap
+      def map(&blk)
+        result = super
+        if self.class._pippi_check_map_followed_by_flatten.nil?
+          # Ignore Array subclasses since map or flatten may have difference meanings
+        else
+          result.extend MyFlatten
+          self.class._pippi_check_map_followed_by_flatten.array_mutator_methods.each do |this_means_its_ok_sym|
+            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_map_followed_by_flatten.its_ok_watcher_proc(MyFlatten, :flatten))
+          end
+        end
+        result
+      end
+    end
+
+    def decorate
+      Array.class_exec(self) do |my_check|
+        # How to do this without a class instance variable?
+        @_pippi_check_map_followed_by_flatten = my_check
+        def self._pippi_check_map_followed_by_flatten
+          @_pippi_check_map_followed_by_flatten
+        end
+      end
+      Array.prepend MyMap
+    end
+
+    class Documentation
+      def description
+        "Don't use map followed by flatten; use flat_map instead"
+      end
+      def sample
+        "[1,2,3].map {|x| [x,x+1] }.flatten"
+      end
+      def instead_use
+        "[1,2,3].flat_map {|x| [x, x+1]}"
+      end
+    end
+
+  end
+
+end

data/lib/pippi/checks/reverse_followed_by_each.rb

@@ -0,0 +1,53 @@
+module Pippi::Checks
+
+  class ReverseFollowedByEach < Check
+
+    module MyEach
+      def each
+        result = super()
+        self.class._pippi_check_reverse_followed_by_each.add_problem
+        result
+      end
+    end
+
+    module MyReverse
+      def reverse
+        result = super
+        if self.class._pippi_check_reverse_followed_by_each.nil?
+          # Ignore Array subclasses since reverse or each may have difference meanings
+        else
+          result.singleton_class.prepend MyEach
+          self.class._pippi_check_reverse_followed_by_each.array_mutator_methods.each do |this_means_its_ok_sym|
+            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_reverse_followed_by_each.its_ok_watcher_proc(MyEach, :each))
+          end
+        end
+        result
+      end
+    end
+
+    def decorate
+      Array.class_exec(self) do |my_check|
+        # How to do this without a class instance variable?
+        @_pippi_check_reverse_followed_by_each = my_check
+        def self._pippi_check_reverse_followed_by_each
+          @_pippi_check_reverse_followed_by_each
+        end
+      end
+      Array.prepend MyReverse
+    end
+
+    class Documentation
+      def description
+        "Don't use each followed by reverse; use reverse_each instead"
+      end
+      def sample
+        "[1,2,3].reverse.each {|x| x+1 }"
+      end
+      def instead_use
+        "[1,2,3].reverse_each {|x| x+1 }"
+      end
+    end
+
+  end
+
+end

data/lib/pippi/checks/select_followed_by_first.rb

@@ -0,0 +1,58 @@
+module Pippi::Checks
+
+  class SelectFollowedByFirst < Check
+
+    module MyFirst
+      def first(elements=nil)
+        result = if elements
+          super(elements)
+        else
+          super()
+        end
+        unless elements
+          self.class._pippi_check_select_followed_by_first.add_problem
+        end
+        result
+      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
+    end
+
+    def decorate
+      Array.class_exec(self) do |my_check|
+        @_pippi_check_select_followed_by_first = my_check
+        def self._pippi_check_select_followed_by_first
+          @_pippi_check_select_followed_by_first
+        end
+      end
+      Array.prepend MySelect
+    end
+
+    class Documentation
+      def description
+        "Don't use select followed by first; use detect instead"
+      end
+      def sample
+        "[1,2,3].select {|x| x > 1 }.first"
+      end
+      def instead_use
+        "[1,2,3].detect {|x| x > 1 }"
+      end
+    end
+
+  end
+
+end

data/lib/pippi/checks/select_followed_by_size.rb

@@ -0,0 +1,59 @@
+module Pippi::Checks
+
+  class SelectFollowedBySize < Check
+
+    module MySize
+      def size
+        result = super()
+        self.class._pippi_check_select_followed_by_size.add_problem
+        self.class._pippi_check_select_followed_by_size.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._pippi_check_select_followed_by_size.clear_fault_proc)
+        end
+        result
+      end
+    end
+
+    module MySelect
+      def select(&blk)
+        result = super
+        if self.class._pippi_check_select_followed_by_size.nil?
+          # Ignore Array subclasses since select or size may have difference meanings
+        else
+          result.extend MySize
+          self.class._pippi_check_select_followed_by_size.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_size.its_ok_watcher_proc(MySize, :size))
+          end
+        end
+        result
+      end
+    end
+
+    def method_names_that_indicate_this_is_being_used_as_a_collection
+      [:collect!, :compact!, :flatten!, :map!, :reject!, :reverse!, :rotate!, :select!, :shuffle!, :slice!, :sort!, :sort_by!, :uniq!, :collect, :compact, :flatten, :map, :reject, :reverse, :rotate, :select, :shuffle, :slice, :sort, :sort_by, :uniq]
+    end
+
+    def decorate
+      Array.class_exec(self) do |my_check|
+        @_pippi_check_select_followed_by_size = my_check
+        def self._pippi_check_select_followed_by_size
+          @_pippi_check_select_followed_by_size
+        end
+      end
+      Array.prepend MySelect
+    end
+
+    class Documentation
+      def description
+        "Don't use select followed by size; use count instead"
+      end
+      def sample
+        "[1,2,3].select {|x| x > 1 }.size"
+      end
+      def instead_use
+        "[1,2,3].count {|x| x > 1 }"
+      end
+    end
+
+  end
+
+end

data/lib/pippi/context.rb

@@ -0,0 +1,31 @@
+module Pippi
+
+  class Context
+
+    class DebugLogger
+      def warn(str)
+        File.open("pippi_debug.log", "a") do |f|
+          f.syswrite("#{str}\n")
+        end
+      end
+    end
+
+    class NullLogger
+      def warn(str)
+      end
+    end
+
+    attr_reader :report, :debug_logger
+
+    def initialize
+      @report = Pippi::Report.new
+      @debug_logger = if ENV['PIPPI_DEBUG']
+        Pippi::Context::DebugLogger.new
+      else
+        Pippi::Context::NullLogger.new
+      end
+    end
+
+  end
+
+end

data/lib/pippi/exec_runner.rb

@@ -0,0 +1,34 @@
+module Pippi
+
+  class ExecRunner
+
+    attr_accessor :codefile, :check_name, :code_to_eval, :output_file_name
+
+    def initialize(args)
+      @codefile = args[0]
+      @check_name = args[1]
+      @code_to_eval = args[2]
+      @output_file_name = args[3]
+    end
+
+    def run
+      ctx = Pippi::Context.new
+      CheckLoader.new(ctx, check_name).checks.each do |check|
+        check.decorate
+      end
+      load "#{codefile}"
+      eval code_to_eval
+      dump_report ctx
+    end
+
+    def dump_report(ctx)
+      File.open(output_file_name, "w") do |outfile|
+        ctx.report.problems.each do |problem|
+          outfile.syswrite("#{problem.to_text}\n")
+        end
+      end
+    end
+
+  end
+
+end

data/lib/pippi/problem.rb

@@ -0,0 +1,24 @@
+module Pippi
+  class Problem
+
+    attr_accessor :file_path, :line_number, :check_class
+
+    def initialize(opts)
+      @file_path = opts[:file_path]
+      @check_class = opts[:check_class]
+      @line_number = opts[:line_number]
+    end
+
+    # TODO probably need various reporting formats
+    def to_text
+      "#{file_path},#{check_class.name.split('::').last},#{line_number}"
+    end
+
+    # TODO correct method?
+    def eql?(other)
+      file_path == other.file_path &&
+      check_class == other.check_class &&
+      line_number == other.line_number
+    end
+  end
+end

data/lib/pippi/report.rb

@@ -0,0 +1,27 @@
+module Pippi
+
+  class Report
+
+    attr_reader :problems
+
+    def initialize
+      @problems = []
+    end
+
+    def add(problem)
+      @problems << problem unless duplicate_report?(problem)
+    end
+
+    def remove(lineno, path, clazz)
+      @problems.reject! {|p| p.line_number == lineno && p.file_path == path && p.check_class == clazz }
+    end
+
+    private
+
+    def duplicate_report?(candidate)
+      !problems.detect {|existing| existing.eql?(candidate) }.nil?
+    end
+
+  end
+
+end

data/lib/pippi/tasks.rb

@@ -0,0 +1,41 @@
+require 'pippi'
+
+module Pippi
+  class Documentation
+    def generate
+      str = ""
+      [Pippi::Checks::SelectFollowedBySize::Documentation,
+       Pippi::Checks::SelectFollowedByFirst::Documentation,
+       Pippi::Checks::ReverseFollowedByEach::Documentation,
+       Pippi::Checks::MapFollowedByFlatten::Documentation
+      ].sort {|a,b| a.name <=> b.name }.each do |clz|
+        obj = clz.new
+        str << %Q{
+### #{clz.name.to_s.split('::')[2]}
+
+#{obj.description}
+
+For example, rather than doing this:
+
+\`\`\`ruby
+#{obj.sample}
+\`\`\`
+
+Instead, consider doing this:
+
+\`\`\`ruby
+#{obj.instead_use}
+\`\`\`
+}
+      end
+      File.open("doc/docs.md", "w") {|f| f.syswrite(str) }
+    end
+  end
+end
+
+namespace :pippi do
+  desc "Generate check documentation"
+  task :generate_docs do
+    Pippi::Documentation.new.generate
+  end
+end

data/lib/pippi/version.rb

@@ -0,0 +1,3 @@
+module Pippi
+  VERSION = "0.0.1"
+end

data/pippi.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'pippi/version'
+
+Gem::Specification.new do |s|
+  s.name = 'pippi'
+  s.version = Pippi::VERSION
+  s.authors = ["Tom Copeland"]
+  s.email = ["tom@thomasleecopeland.com"]
+  s.homepage = "https://github.com/tcopeland/pippi"
+  s.summary = "A Ruby runtime code analyzer"
+  s.description = "Pippi is a utility for locating suboptimal Ruby class API usage."
+  s.license = "MIT"
+  s.rubyforge_project = "none"
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files test/*`.split("\n")
+  s.executables = "pippi"
+  s.require_paths = ["lib"]
+  s.add_development_dependency 'rake', '~> 10.1'
+  s.add_development_dependency 'minitest', '~> 5.0'
+  s.add_development_dependency 'byebug', '~> 2.7'
+  s.required_ruby_version = '>= 2.0.0'
+end

data/sample/map_followed_by_flatten.rb

@@ -0,0 +1,6 @@
+class Foo
+  def bar
+    x = [1,2,3]
+    x.map {|y| [y, y+1] }.flatten
+  end
+end