nitpick 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2008 Kevin Clark
+
+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

@@ -0,0 +1,56 @@
+Ruby lint. Sorta.
+
+http://github.com/kevinclark/nitpick/wikis
+
+
+Clio:nitpick kev$ ./bin/nitpick spec/fixtures/block_badness.rb \
+>     spec/fixtures/branch_badness.rb \
+>     spec/fixtures/method_badness.rb \
+>     spec/fixtures/rescue_badness.rb \
+>     spec/fixtures/local_variable_badness.rb
+./spec/fixtures/branch_badness.rb:20: warning: found = in conditional, should be ==
+Fixtures::BlockBadness
+  no_conditional_for_block_given
+    - A block is being yielded to without a check for block_given?
+  simple_conditional_without_check
+    - A block is being yielded to without a check for block_given?
+
+Fixtures::BranchBadness
+  branch_returning_identical_things
+    - The branches of 'if (true)' are identical.
+  branch_returning_true_or_false
+    - No need for an if. Just return '(1 == 2)' as a boolean.
+  branch_with_assignment_as_condition
+    - An assigment is being used as a condition: (a = 1)
+    - The variable :a is unused.
+
+Fixtures::LocalVariableBadness
+  anonymous_args
+    - The method :anonymous_args is empty.
+  block_arg_unused
+    - The argument :block is unused.
+  lvar_shadowed
+    - One or more variables are being shadowed (x)
+  lvar_shadowed_many_block_vars
+    - One or more variables are being shadowed (x)
+  rescue_to_variable
+    - The variable :e is unused.
+  simple_unused_arg
+    - The argument :other is unused.
+  unused_arg
+    - The argument :arg is unused.
+  unused_lasgn
+    - The variable :bar is unused.
+
+Fixtures::MethodBadness
+  empty_method
+    - The method :empty_method is empty.
+
+Fixtures::RescueBadness
+  rescue_exception
+    - A rescue is capturing Object or Exception, which may hide errors.
+  rescue_nil
+    - A rescue is returning "nil" directly and may not handle an error.
+  rescue_object
+    - A rescue is capturing Object or Exception, which may hide errors.
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 0
+:major: 1

data/bin/nitpick

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+require 'pp'
+
+require 'rubygems'
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'nitpick'
+
+# {Constant => {Method => [Warnings]}}
+$warnings = Hash.new {|h,k| h[k] = Hash.new {|_h,_k| _h[_k] = [] }}
+
+require 'trollop'
+opts = Trollop.options do
+  banner <<-BANNER
+Nitpick is a lint-like static code analyzer for Ruby.
+
+Usage: `nitpick [(--only str | --except str)*|-h] file1.rb file2.rb`
+
+By default, nitpick will analyze *all* loaded code. To reduce the noise:
+
+BANNER
+  opt :only, "Nitpick only classes/modules that match this string.", :type => :string, :multi => true
+  opt :except, "Don't nitpick classes/modules that match this string.", :type => :string, :multi => true
+end
+
+# TODO(kevinclark) 2009-03-19: Figure out how to make this print -h
+Trollop.die "I need something to nitpick. Gimmie a filename or two. Or ten" if ARGV.size == 0
+
+NitpickOptions = { :only => opts[:only] || [], :except => opts[:except] || []}
+Nitpickers = [
+  Nitpick::ArgumentNitpicker, Nitpick::BlockNitpicker, Nitpick::BranchNitpicker,
+  Nitpick::LocalVariableNitpicker, Nitpick::MethodNitpicker, Nitpick::RescueNitpicker
+]
+
+class Module
+  # So we don't set off -w
+  alias_method :original_method_added, :method_added
+  
+  def method_added(name)
+    original_method_added(name)
+    
+    # Except means don't match this
+    return if NitpickOptions[:except].any? {|namespace| /#{namespace}/ =~ self.to_s }
+    # Only means it must match one
+    return unless NitpickOptions[:only].find? {|namespace|  /#{namespace}/ =~ self.to_s } or
+                    NitpickOptions[:only].empty?
+    
+    warnings = Nitpickers.map do |nitpicker_class|
+      nitpicker = nitpicker_class.new(self, name)
+      nitpicker.nitpick!
+      nitpicker.warnings
+    end.flatten
+    
+    $warnings[self.name][name.to_s] = warnings
+  end
+end
+
+at_exit do
+  # Prune empty classes and methods
+  $warnings.each do |klass, methods|
+    methods.each do |meth, warnings|
+      $warnings[klass].delete(meth) if warnings.empty?
+    end
+    $warnings.delete(klass) if $warnings[klass].empty?
+  end
+  
+  puts "Nothing to report boss! He's clean!" if $warnings.empty?
+  
+  class_names_in_order = $warnings.keys.sort
+  
+  class_names_in_order.each do |klass|
+    puts "#{klass}"
+    
+    methods_in_order = $warnings[klass].keys.sort
+    
+    methods_in_order.each do |meth|
+      puts "  #{meth}"
+      
+      $warnings[klass][meth].each do |w|
+        puts "    - #{w.message}"
+      end
+    end
+    puts
+  end
+end
+
+ARGV.each do |file|
+  begin
+    load file
+  rescue Exception => e # grab *everything*
+    $stderr.puts "*** Nitpick had trouble loading #{file.inspect}:\n\t#{e.class} #{e.message}"
+  end
+end

data/lib/nitpick.rb

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'parse_tree'
+require 'ruby2ruby'
+
+require 'nitpick/warnings/simple_warning'
+require 'nitpick/warnings/unused_variable'
+require 'nitpick/warnings/unprotected_block'
+require 'nitpick/warnings/useless_branch'
+require 'nitpick/warnings/identical_branch'
+require 'nitpick/warnings/rescue_value'
+require 'nitpick/warnings/rescue_everything'
+require 'nitpick/warnings/unused_argument'
+require 'nitpick/warnings/assignment_as_condition'
+require 'nitpick/warnings/shadowed_variable'
+require 'nitpick/warnings/empty_method'
+
+require 'nitpick/nitpicker'
+require 'nitpick/local_variable_counter'
+require 'nitpick/local_variable_nitpicker'
+require 'nitpick/argument_nitpicker'
+require 'nitpick/block_nitpicker'
+require 'nitpick/branch_nitpicker'
+require 'nitpick/rescue_nitpicker'
+require 'nitpick/method_nitpicker'
+
+
+require 'nitpick/sexp_extension'
+class Sexp
+  include Nitpick::SexpExtension
+end

data/lib/nitpick/argument_nitpicker.rb

@@ -0,0 +1,21 @@
+module Nitpick
+  class ArgumentNitpicker < LocalVariableCounter
+    def nitpick!
+      @silence_warnings = false
+      super
+      return if @silence_warnings
+      
+      @lvars.each do |name, details|
+        next if details[:calls] > 0
+        next if details[:uses] >= 2
+        next if !@args.include?(name)
+        warn Warnings::UnusedArgument.new(name)
+      end
+    end
+    
+    def process_zsuper(exp)
+      @silence_warnings = true
+      s(:zsuper)
+    end
+  end
+end

data/lib/nitpick/block_nitpicker.rb

@@ -0,0 +1,21 @@
+module Nitpick
+  class BlockNitpicker < Nitpicker
+    def process_if(exp)
+      cond = Sexp.from_array(exp.shift)
+      yes_branch = Sexp.from_array(exp.shift)
+      no_branch = Sexp.from_array(exp.shift)
+      
+      scan_for [Warnings::UnprotectedBlock],
+           :with => [cond, yes_branch, no_branch]
+      
+      s(:if, cond, yes_branch, no_branch)
+    end
+    
+    def process_yield(exp)
+      exp.clear
+      warn Warnings::UnprotectedBlock.new
+      
+      s(:yield)
+    end
+  end
+end

data/lib/nitpick/branch_nitpicker.rb

@@ -0,0 +1,17 @@
+module Nitpick
+  class BranchNitpicker < Nitpicker
+    def process_if(exp)
+      cond = process(exp.shift)
+      yes_branch = process(exp.shift)
+      no_branch = process(exp.shift)
+      
+      scan_for [Warnings::UselessBranch, Warnings::IdenticalBranch],
+           :with => [cond, yes_branch, no_branch]
+      
+      scan_for [Warnings::AssignmentAsCondition],
+           :with => [cond]
+      
+      s(:if, cond, yes_branch, no_branch)
+    end
+  end
+end

data/lib/nitpick/local_variable_counter.rb

@@ -0,0 +1,81 @@
+module Nitpick
+  class LocalVariableCounter < Nitpicker
+    def initialize(klass, meth)
+      super
+      # uses.succ each time a local variable is referenced or assigned to
+      # calls.succ each time a message is sent to a lvar (foo.bar)
+      @lvars = Hash.new {|h,k| h[k] = {:uses => 0, :calls => 0}}
+      @args = []
+    end
+    
+    def uses(name)
+      @lvars[name][:uses]
+    end
+    
+    def use(name)
+      @lvars[name][:uses] += 1
+    end
+    
+    def call(name)
+      @lvars[name][:calls] += 1
+    end
+    
+    def process_lasgn(exp)
+      name = exp.shift
+      value = exp.shift
+      
+      use name
+      process(value)
+      
+      s(:lasgn, name, value)
+    end
+    
+    def process_iasgn(exp)
+      name = exp.shift
+      value = exp.shift
+      
+      process(value)
+      
+      s(:iasgn, name, value)
+    end
+    
+    def process_call(exp)
+      recv = process(exp.shift)
+      meth = exp.shift
+      args = process(exp.shift)
+
+      call recv.last if recv.first == :lvar
+      
+      s(:call, recv, meth, args)
+    end
+    
+    def process_lvar(exp)
+      name = exp.shift
+      use name
+      s(:lvar, name)
+    end
+    
+    def process_args(exp)
+      exp.each do |arg|
+        next unless arg.is_a? Symbol
+        
+        name = arg.to_s.gsub(/^\*/, '')
+        next if name == ""
+        
+        @args << name.to_sym
+        use name.to_sym
+      end
+      
+      exp.clear
+      
+      s(:args, *@args)
+    end
+    
+    def process_block_arg(exp)
+      name = exp.shift
+      @args << name
+      use name
+      s(:block_arg, name)
+    end
+  end
+end

data/lib/nitpick/local_variable_nitpicker.rb

@@ -0,0 +1,26 @@
+module Nitpick
+  class LocalVariableNitpicker < LocalVariableCounter
+    def nitpick!
+      super
+      
+      @lvars.each do |name, details|
+        next if @args.include? name
+        next if details[:calls] > 0
+        # The first assignment is a use
+        next if details[:uses] > 1
+        warn Warnings::UnusedVariable.new(name)
+      end
+    end
+    
+    def process_iter(exp)
+      call = process(exp.shift)
+      assignments = process(exp.shift)
+      block = process(exp.shift)
+      
+      scan_for [Warnings::ShadowedVariable],
+          :with => [assignments]
+          
+      s(:iter, call, assignments, block)
+    end
+  end
+end

data/lib/nitpick/method_nitpicker.rb

@@ -0,0 +1,14 @@
+module Nitpick
+  class MethodNitpicker < Nitpicker
+    def process_defn(exp)
+      # def foo(x); 1 end =>
+      #   [:defn, :foo, [:scope, [:block, [:args, :x], [:lit, 1]]]]
+      name, (_scope, (_block, (_argsym, *args), body)) = exp
+
+      scan_for [Warnings::EmptyMethod],
+           :with => [name, args, body]
+      
+      super
+    end
+  end
+end

data/lib/nitpick/nitpicker.rb

@@ -0,0 +1,46 @@
+module Nitpick
+  class Nitpicker < SexpProcessor
+    attr_accessor :warnings
+    
+    def initialize(klass, meth)
+      super()
+      self.auto_shift_type = true
+      self.strict = false
+      self.expected = Sexp
+      
+      @unsupported.delete(:cfunc)
+      @class = klass
+      @method = meth
+      @warnings = []
+    end
+    
+    def nitpick!
+      process(ParseTree.translate(@class, @method))
+    end
+    
+    def scan_for(warning_classes, options = {})
+      matched_warnings = warning_classes.map do |warning_class|
+        warning_class.discover(options[:with])
+      end
+      
+      warn(*matched_warnings)
+    end
+    
+    def warn(*warnings)
+      @warnings += warnings.compact
+    end
+    
+    def process_defn(exp)
+      method = exp.shift
+      result = s(:defn, method)
+      
+      until exp.empty?
+        result << process(exp.shift)
+      end
+
+      result
+    end
+    
+    def process_cfunc(exp); exp.clear; s(); end
+  end
+end