reek 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-09-08
+
+* 1 major enhancement:
+  * Initial release

data/README.txt

@@ -0,0 +1,54 @@
+= reek
+
+* http://rubyforge.org/projects/reek/
+* http://www.refactoring-workbook.com/reek
+* mailto:kevin@rutherford-software.com
+
+== DESCRIPTION:
+
+Reek is a tool that examines Ruby classes, modules and methods and
+reports any code smells it finds.
+
+== FEATURES/PROBLEMS:
+
+* Not many smells checked right now; more coming soon.
+* The current Feature Envy check is probably over zealous.
+* There's no convenient programmer's API just yet.
+
+== SYNOPSIS:
+
+  $ cd my_project/lib
+  $ reek
+
+== REQUIREMENTS:
+
+* ParseTree
+
+== INSTALL:
+
+* sudo gem install reek
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) Kevin Rutherford, Rutherford Software
+
+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/Rakefile

@@ -0,0 +1,6 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+task :default => :spec

data/bin/reek

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-2-17.
+#  Copyright (c) 2008. All rights reserved.
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # no rubygems to load, so we fail silently
+end
+
+require 'reek'
+
+def classes_currently_loaded
+  result = []
+  ObjectSpace.each_object(Module) { |klass| result << klass }
+  result
+end
+
+old_classes = classes_currently_loaded
+files = ARGV
+files = Dir['**/*.rb'] if files.empty?
+files.each { |name| require name }
+new_classes = classes_currently_loaded - old_classes
+if new_classes.empty?
+  puts 'Nothing to analyse!'
+else
+  puts Reek.analyse(*new_classes).to_s
+end

data/lib/reek/checker.rb

@@ -0,0 +1,40 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+
+module Reek
+
+  class Checker < SexpProcessor
+    attr_accessor :description
+
+    def initialize(smells)
+      super()
+      @require_empty = false
+      @smells = smells
+      @description = ''
+      @unsupported -= [:cfunc]
+    end
+
+    def report(smell)
+      @smells << smell
+    end
+
+    def check_source(code)
+      check_parse_tree ParseTree.new.parse_tree_for_string(code)
+    end
+
+    def check_object(obj)
+      check_parse_tree ParseTree.new.parse_tree(obj)
+    end
+    
+    def to_s
+      description
+    end
+
+    def check_parse_tree(sexp)
+      sexp.each { |exp| process(exp) }
+    end
+  end
+end

data/lib/reek/class_checker.rb

@@ -0,0 +1,29 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/checker'
+require 'reek/method_checker'
+
+module Reek
+
+  class ClassChecker < Checker
+
+    def initialize(smells)
+      super(smells)
+      @description = ''
+    end
+
+    def process_class(exp)
+      @description = exp[1].to_s
+      superclass = exp[2]
+      LargeClass.check(@description, self)
+      exp[3..-1].each { |defn| process(defn) } unless superclass == [:const, :Struct]
+      s(exp)
+    end
+
+    def process_defn(exp)
+      bc = Reek::MethodChecker.new(@smells, @description)
+      bc.process(exp)
+      s(exp)
+    end  
+  end
+end

data/lib/reek/method_checker.rb

@@ -0,0 +1,109 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/checker'
+require 'reek/smells'
+require 'set'
+
+module Reek
+
+  class MethodChecker < Checker
+
+    def initialize(smells, klass_name)
+      super(smells)
+      @class_name = klass_name
+      @description = klass_name
+      @top_level_block = true
+      @calls = Hash.new(0)
+      @lvars = Set.new
+    end
+
+    def process_defn(exp)
+      @description = "#{@class_name}##{exp[1]}"
+      UncommunicativeName.check(exp[1], self, 'method')
+      process(exp[2])
+      @lvars.each {|lvar| UncommunicativeName.check(lvar, self, 'local variable') }
+      UtilityFunction.check(@calls, self)
+      FeatureEnvy.check(@calls, self)
+      s(exp)
+    end
+
+    def process_args(exp)
+      LongParameterList.check(exp, self)
+      exp.each { |arg| UncommunicativeName.check(arg, self, 'parameter') }
+      s(exp)
+    end
+
+    def process_attrset(exp)
+      @calls[:self] += 1 if /^@/ === exp[1].to_s
+      s(exp)
+    end
+
+    def process_iter(exp)
+      @top_level_block = false
+      exp[1..-1].each { |s| process(s) }
+      s(exp)
+    end
+
+    def process_block(exp)
+      if @top_level_block
+        LongMethod.check(exp, self)
+      else
+        LongBlock.check(exp, self)
+      end
+      exp[1..-1].each { |s| process(s) }
+      s(exp)
+    end
+
+    def process_yield(exp)
+      LongYieldList.check(exp[1], self)
+      process(exp[1])
+      s(exp)
+    end
+
+    def process_call(exp)
+      receiver = process(exp[1])
+      receiver = receiver[0] if Array === receiver and Array === receiver[0] and receiver.length == 1
+      if receiver[0] != :gvar
+        receiver = :self if receiver == s(:self)
+        @calls[receiver] += 1
+      end
+      process(exp[3]) if exp.length > 3
+      s(exp)
+    end
+
+    def process_fcall(exp)
+      @calls[:self] += 1
+      process(exp[2]) if exp.length > 2
+      s(exp)
+    end
+
+    def process_cfunc(exp)
+      @calls[:self] += 1
+      s(exp)
+    end
+
+    def process_vcall(exp)
+      @calls[:self] += 1
+      s(exp)
+    end
+
+    def process_ivar(exp)
+      UncommunicativeName.check(exp[1], self, 'field')
+      @calls[:self] += 1
+      s(exp)
+    end
+
+    def process_lasgn(exp)
+      @lvars << exp[1]
+      @calls[s(:lvar, exp[1])] += 1
+      process(exp[2])
+      s(exp)
+    end
+
+    def process_iasgn(exp)
+      @calls[:self] += 1
+      process(exp[2])
+      s(exp)
+    end
+  end
+end

data/lib/reek/printer.rb

@@ -0,0 +1,53 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+
+module Reek
+
+  class Printer < SexpProcessor
+    def self.print(sexp)
+      new.print(sexp)
+    end
+
+    def initialize
+      super
+      @require_empty = false
+      @report = ''
+    end
+
+    def print(sexp)
+      @report = sexp.inspect
+      process(sexp)
+      @report
+    end
+
+    def process_lvar(exp)
+      @report = exp[1].inspect
+      s(exp)
+    end
+
+    def process_dvar(exp)
+      @report = exp[1].inspect
+      s(exp)
+    end
+
+    def process_gvar(exp)
+      @report = exp[1].inspect
+      s(exp)
+    end
+
+    def process_const(exp)
+      @report = exp[1].inspect
+      s(exp)
+    end
+
+    def process_call(exp)
+      @report = "#{exp[1]}.#{exp[2]}"
+      @report += "(#{exp[3]})" if exp.length > 3
+      s(exp)
+    end
+  end
+  
+end

data/lib/reek/report.rb

@@ -0,0 +1,30 @@
+$:.unshift File.dirname(__FILE__)
+
+module Reek
+
+  class Report
+    def initialize
+      @smells = []
+    end
+
+    def <<(smell)
+      @smells << smell
+    end
+    
+    def empty?
+      @smells.empty?
+    end
+    
+    def length
+      @smells.length
+    end
+    
+    def [](i)
+      @smells[i]
+    end
+
+    def to_s
+      @smells.map {|smell| smell.report}.join("\n")
+    end
+  end
+end

data/lib/reek/smells.rb

@@ -0,0 +1,159 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/printer'
+
+module Reek
+
+  class Smell
+    def self.convert_camel_case(class_name)
+      class_name.gsub(/([a-z])([A-Z])/) { |s| "#{$1} #{$2}"}
+    end
+
+    def initialize(context, arg=nil)
+      @context = context
+    end
+
+    def self.check(exp, context, arg=nil)
+      smell = new(context, arg)
+      context.report(smell) if smell.recognise?(exp)
+    end
+
+    def ==(other)
+      self.report == other.report
+    end
+    
+    def name
+      self.class.convert_camel_case(self.class.name.split(/::/)[1])
+    end
+
+    def report
+      "[#{name}] #{detailed_report}"
+    end
+  end
+
+  class LongParameterList < Smell
+    MAX_ALLOWED = 3
+
+    def count_parameters(exp)
+      result = exp.length - 1
+      result -= 1 if Array === exp[-1] and exp[-1][0] == :block
+      result
+    end
+
+    def recognise?(args)
+      count_parameters(args) > MAX_ALLOWED
+    end
+
+    def detailed_report
+      "#{@context.to_s} has > #{MAX_ALLOWED} parameters"
+    end
+  end
+
+  class LongYieldList < LongParameterList
+    def recognise?(args)
+      Array === args and args.length > MAX_ALLOWED
+    end
+
+    def detailed_report
+      "#{@context} yields > #{MAX_ALLOWED} parameters"
+    end
+  end
+
+  class LongMethod < Smell
+    MAX_ALLOWED = 5
+
+    def count_statements(exp)
+      result = exp.length - 1
+      result -= 1 if Array === exp[1] and exp[1][0] == :args
+      result
+    end
+
+    def recognise?(exp)
+      count_statements(exp) > MAX_ALLOWED
+    end
+
+    def detailed_report
+      "#{@context} has > #{MAX_ALLOWED} statements"
+    end
+  end
+
+  class LongBlock < Smell
+    MAX_ALLOWED = 5
+
+    def count_statements(exp)
+      result = exp.length - 1
+      result -= 1 if Array === exp[1] and exp[1][0] == :args
+      result
+    end
+
+    def recognise?(exp)
+      count_statements(exp) > MAX_ALLOWED
+    end
+
+    def detailed_report
+      "#{@context} has a block with > #{MAX_ALLOWED} statements"
+    end
+  end
+
+  class FeatureEnvy < Smell
+    def initialize(context, receiver)
+      super
+      @receiver = receiver
+    end
+
+    def recognise?(calls)
+      max = calls.empty? ? 0 : calls.values.max
+      mine = calls[:self]
+      return false unless max > mine
+      receivers = calls.keys.select { |key| calls[key] == max }
+      @receiver = receivers.map {|r| Printer.print(r)}.sort.join(' or ')
+      return true
+    end
+
+    def detailed_report
+      "#{@context} could be moved to #{@receiver}"
+    end
+  end
+
+  class UtilityFunction < Smell
+    def recognise?(calls)
+      calls[:self] == 0
+    end
+
+    def detailed_report
+      "#{@context} doesn't depend on instance state"
+    end
+  end
+
+  class LargeClass < Smell
+    MAX_ALLOWED = 25
+
+    def recognise?(name)
+      kl = Object.const_get(name) rescue return
+      num_methods = kl.instance_methods.length - kl.superclass.instance_methods.length
+      num_methods > MAX_ALLOWED
+    end
+
+    def detailed_report
+      "#{@context} has > #{MAX_ALLOWED} methods"
+    end
+  end
+
+  class UncommunicativeName < Smell
+    def initialize(context, symbol_type)
+      super
+      @symbol_type = symbol_type
+    end
+
+    def recognise?(symbol)
+      @symbol = symbol.to_s
+      return false if @symbol == '*'
+      min_len = (/^@/ === @symbol) ? 3 : 2;
+      @symbol.length < min_len
+    end
+
+    def detailed_report
+      "#{@context} uses the #{@symbol_type} name '#{@symbol}'"
+    end
+  end
+end

data/lib/reek/version.rb

@@ -0,0 +1,9 @@
+module Reek #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/reek.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/class_checker'
+require 'reek/report'
+
+module Reek
+
+  def self.analyse(*klasses)
+    report = Report.new
+    klasses.each do |klass|
+      ClassChecker.new(report).check_object(klass)
+    end
+    report
+  end
+  
+end