kevinrutherford-reek 0.3.1.4

data/History.txt

@@ -0,0 +1,92 @@
+== 0.3.x 2009-??-??
+
+=== Major enhancements:
+
+* Place *.reek files in source folder to configure smell detection behaviour
+* Added -f option to configure report format
+* --sort_order replaced by -f, -c and -s
+* Matchers provided for rspec; eg. foo.should_not reek
+
+=== Minor enhancements:
+
+* Smells in singleton methods are now analysed
+* Uncommunicative parameter names in blocks now reported
+* Modules and blocks now reflected in scope of smell reports
+
+=== Fixes:
+
+* Corrected false reports of long arg lists to yield
+* A method can now be a UtilityFunction only when it includes a call
+* Removed the website from the gem [#12]
+
+== 0.3.1 2008-11-17
+
+* Minor enhancements:
+  * Uncommunicative Name now checks instance variables more thoroughly
+  * Uncommunicative Name now warns about names of the form 'x2'
+  * Added check for duplicated calls within a method
+  * Reduced scope of Feature Envy warnings to cover only overuse of lvars
+  * Added rdoc comments explaining what each smell is about
+  * Chained iterators are no longer mis-reported as nested
+
+== 0.3.0 2008-11-02
+
+* Minor enhancements:
+  * New smell: first naive checks for Control Couple
+  * reek now only checks sources passed on the command line
+  * Code snippets can be supplied on the commandline
+  * Added headings and warnings count when smells in multiple files
+  * Added Reek::RakeTask to run reek from rakefiles
+* Tweaks:
+  * Fixed: Returns exit status 2 when smells are reported
+  * Fixed: no longer claims an empty method is a Utility Function
+
+== 0.2.3 2008-09-22
+
+* Minor enhancements:
+  * Only reports Feature Envy when the method isn't a Utility Function
+  * General improvements to assessing Feature Envy
+* Tweaks:
+  * Fixed: coping with parameterless yield call
+  * Fixed: copes with :self as an expression
+  * Fixed: displaying the receiver of many more kinds of Feature Envy
+  * Fixed: Large Class calculation for Object
+
+== 0.2.2 2008-09-15
+
+* Tweaks:
+  * Fixed --version!
+
+== 0.2.1 2008-09-14
+
+* Tweaks:
+  * Now works from the source code, instead of requiring each named file
+  * Added integration tests that run reek on a couple of gems
+
+== 0.2.0 2008-09-10
+
+* Minor enhancements:
+  * Added --help, --version options
+  * Added --sort option to sort the report by smell or by code location
+
+== 0.1.1 2008-09-09
+
+* Some tweaks:
+  * Fixed report printing for Feature Envy when the receiver is a block
+  * Fixed: successive iterators reported as nested
+  * Fixed: Long Method now reports the total length of the method
+  * Fixed: each smell reported only once
+
+== 0.1.0 2008-09-09
+
+* 1 minor enhancement:
+  * Added a check for nested iterators within a method
+* Some tweaks:
+  * Begun adding some rdoc
+  * Split some of the specs into more meaningful chunks
+  * Updated the rakefile so that rcov is no longer the default
+
+== 0.0.1 2008-09-08
+
+* 1 major enhancement:
+  * Initial release

data/README.txt

@@ -0,0 +1,6 @@
+= Reek
+
+Code smell detection for Ruby.
+
+The documentation is at http://wiki.github.com/kevinrutherford/reek
+The code lives at http://github.com/kevinrutherford/reek/tree

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake'
+require 'rake/clean'
+require 'fileutils'
+
+$:.unshift File.dirname(__FILE__) + '/lib'
+
+Dir['tasks/**/*.rake'].each { |t| load t }

data/bin/reek

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+# Reek examines Ruby source code for smells.
+# Visit http://reek.rubyforge.org/ for docs etc.
+#
+# Author: Kevin Rutherford
+#
+
+require 'reek'
+require 'reek/source'
+require 'reek/options'
+
+exitstatus = 0
+source = Reek::Options.parse(ARGV)
+if source.smelly?
+  puts source.report
+  exitstatus = 2
+end
+exit(exitstatus)

data/lib/reek/block_context.rb

@@ -0,0 +1,37 @@
+require 'reek/code_context'
+
+module Reek
+  class BlockContext < CodeContext
+
+    def initialize(outer, exp)
+      super
+      @parameters = []
+      @local_variables = []
+      @name = Name.new('block')
+    end
+
+    def inside_a_block?
+      true
+    end
+
+    def has_parameter(name)
+      @parameters.include?(name) or @outer.has_parameter(name)
+    end
+
+    def nested_block?
+      @outer.inside_a_block?
+    end
+    
+    def record_parameter(sym)
+      @parameters << Name.new(sym)
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}/"
+    end
+    
+    def variable_names
+      @parameters + @local_variables
+    end
+  end
+end

data/lib/reek/class_context.rb

@@ -0,0 +1,73 @@
+require 'reek/code_context'
+
+class Class
+  def non_inherited_methods
+    instance_methods(false) + private_instance_methods(false)
+  end
+
+  def is_overriding_method?(sym)
+    instance_methods(false).include?(sym) and superclass.instance_methods(true).include?(sym)
+  end
+end
+
+module Reek
+  class ClassContext < CodeContext
+
+    def ClassContext.create(outer, exp)
+      res = Name.resolve(exp[1], outer)
+      ClassContext.new(res[0], res[1], exp[2])
+    end
+
+    def initialize(outer, name, superclass = nil)
+      super(outer, nil)
+      @name = name
+      @superclass = superclass
+      @parsed_methods = []
+      @instance_variables = []
+    end
+
+    def myself
+      @myself ||= @outer.find_module(@name)
+    end
+
+    def find_module(modname)
+      sym = modname.to_s
+      return nil unless myself
+      myself.const_defined?(sym) ? myself.const_get(sym) : nil
+    end
+
+    def is_overriding_method?(name)
+      return false unless myself
+      myself.is_overriding_method?(name.to_s)
+    end
+    
+    def is_struct?
+      @superclass == [:const, :Struct]
+    end
+
+    def num_methods
+      meths = myself ? myself.non_inherited_methods : @parsed_methods
+      meths.length
+    end
+
+    def record_instance_variable(sym)
+      @instance_variables << Name.new(sym)
+    end
+
+    def record_method(name)
+      @parsed_methods << name.to_s
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}#"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+
+    def variable_names
+      @instance_variables
+    end
+  end
+end

data/lib/reek/code_context.rb

@@ -0,0 +1,47 @@
+module Reek
+  
+  #
+  # Superclass for all types of source code context. Each instance represents
+  # a code element of some kind, and each provides behaviour relevant to that
+  # code element. CodeContexts form a tree in the same way the code does,
+  # with each context holding a reference to a unique outer context.
+  #
+  class CodeContext
+
+    attr_reader :name
+
+    def initialize(outer, exp)
+      @outer = outer
+      @exp = exp
+      @myself = nil
+    end
+
+    def matches?(strings)
+      me = @name.to_s
+      strings.any? do |str|
+        re = /#{str}/
+        re === me or re === self.to_s
+      end
+    end
+    
+    #
+    # Bounces messages up the context tree to the first enclosing context
+    # that knows how to deal with the request.
+    #
+    def method_missing(method, *args)
+      @outer.send(method, *args)
+    end
+
+    def num_methods
+      0
+    end
+
+    def outer_name
+      "#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+  end
+end

data/lib/reek/code_parser.rb

@@ -0,0 +1,204 @@
+require 'rubygems'
+require 'parse_tree'
+require 'sexp_processor'
+require 'reek/block_context'
+require 'reek/class_context'
+require 'reek/module_context'
+require 'reek/stop_context'
+require 'reek/if_context'
+require 'reek/method_context'
+require 'reek/singleton_method_context'
+require 'reek/yield_call_context'
+
+module Reek
+
+  class CodeParser < SexpProcessor
+
+    def self.parse_tree_for(code)   # :nodoc:
+      ParseTree.new.parse_tree_for_string(code)
+    end
+
+    # Creates a new Ruby code checker. Any smells discovered by
+    # +check_source+ or +check_object+ will be stored in +report+.
+    def initialize(report, smells, ctx = StopContext.new)
+      super()
+      @report = report
+      @smells = smells
+      @element = ctx
+      @unsupported -= [:cfunc]
+      @default_method = :process_default
+      @require_empty = @warn_on_default = false
+    end
+
+    # Analyses the given Ruby source +code+ looking for smells.
+    # Any smells found are saved in the +Report+ object that
+    # was passed to this object's constructor.
+    def check_source(code)
+      check_parse_tree(CodeParser.parse_tree_for(code))
+    end
+
+    # Analyses the given Ruby object +obj+ looking for smells.
+    # Any smells found are saved in the +Report+ object that
+    # was passed to this object's constructor.
+    def check_object(obj)
+      check_parse_tree(ParseTree.new.parse_tree(obj))
+    end
+
+    def process_default(exp)
+      exp[1..-1].each { |sub| process(sub) if Array === sub }
+      s(exp)
+    end
+
+    def process_module(exp)
+      push(ModuleContext.create(@element, exp)) do
+        process_default(exp)
+        check_smells(:module)
+      end
+      s(exp)
+    end
+
+    def process_class(exp)
+      push(ClassContext.create(@element, exp)) do
+        process_default(exp) unless @element.is_struct?
+        check_smells(:class)
+      end
+      s(exp)
+    end
+
+    def process_defn(exp)
+      handle_context(MethodContext, :defn, exp)
+    end
+
+    def process_defs(exp)
+      handle_context(SingletonMethodContext, :defs, exp)
+    end
+
+    def process_args(exp)
+      exp[1..-1].each {|sym| @element.record_parameter(sym) }
+      s(exp)
+    end
+
+    def process_attrset(exp)
+      @element.record_depends_on_self if /^@/ === exp[1].to_s
+      s(exp)
+    end
+
+    def process_lit(exp)
+      val = exp[1]
+      @element.record_depends_on_self if val == :self
+      s(exp)
+    end
+
+    def process_iter(exp)
+      process(exp[1])
+      handle_context(BlockContext, :iter, exp[1..-1])
+    end
+    
+    def process_dasgn_curr(exp)
+      @element.record_parameter(exp[1])
+      process_default(exp)
+    end
+
+    def process_block(exp)
+      @element.count_statements(CodeParser.count_statements(exp))
+      process_default(exp)
+    end
+
+    def process_yield(exp)
+      handle_context(YieldCallContext, :yield, exp)
+    end
+
+    def process_call(exp)
+      @element.record_call_to(exp)
+      process_default(exp)
+    end
+
+    def process_fcall(exp)
+      @element.record_depends_on_self
+      @element.refs.record_reference_to_self
+      process_default(exp)
+    end
+
+    def process_cfunc(exp)
+      @element.record_depends_on_self
+      s(exp)
+    end
+
+    def process_vcall(exp)
+      @element.record_depends_on_self
+      @element.refs.record_reference_to_self
+      s(exp)
+    end
+
+    def process_if(exp)
+      handle_context(IfContext, :if, exp)
+    end
+
+    def process_ivar(exp)
+      process_iasgn(exp)
+    end
+
+    def process_lasgn(exp)
+      @element.record_local_variable(exp[1])
+      process(exp[2])
+      s(exp)
+    end
+
+    def process_iasgn(exp)
+      @element.record_instance_variable(exp[1])
+      @element.record_depends_on_self
+      process_default(exp)
+    end
+
+    def process_self(exp)
+      @element.record_depends_on_self
+      s(exp)
+    end
+
+  private
+
+    def self.count_statements(exp)
+      stmts = exp[1..-1]
+      ignore = 0
+      ignore = 1 if is_expr?(stmts[0], :args)
+      ignore += 1 if stmts[1] == s(:nil)
+      stmts.length - ignore
+    end
+
+    def self.is_expr?(exp, type)
+      Array === exp and exp[0] == type
+    end
+
+    def self.is_global_variable?(exp)
+      is_expr?(exp, :gvar)
+    end
+
+    def handle_context(klass, type, exp)
+      push(klass.new(@element, exp)) do
+        process_default(exp)
+        check_smells(type)
+      end
+      s(exp)
+    end
+
+    def check_smells(type)
+      @smells[type].each {|smell| smell.examine(@element, @report) }
+    end
+
+    def push(context)
+      orig = @element
+      @element = context
+      yield
+      @element = orig
+    end
+    
+    def pop(exp)
+      @element = @element.outer
+      s(exp)
+    end
+
+    def check_parse_tree(sexp)  # :nodoc:
+      sexp.each { |exp| process(exp) }
+    end
+  end
+end

data/lib/reek/exceptions.reek

@@ -0,0 +1,13 @@
+--- 
+FeatureEnvy:
+  exclude:
+  - examine_context
+LargeClass:
+  exclude:
+  - CodeParser
+LongMethod:
+  exclude:
+  - Reek::SexpFormatter#self.format
+UtilityFunction:
+  exclude:
+  - Reek::Spec

data/lib/reek/if_context.rb

@@ -0,0 +1,25 @@
+require 'reek/code_context'
+
+module Reek
+  class IfContext < CodeContext
+    attr_reader :if_expr
+    
+    def initialize(outer, exp)
+      @outer = outer
+      @exp = exp
+      @if_expr = exp[1]
+    end
+    
+    def tests_a_parameter?
+      @if_expr[0] == :lvar and has_parameter(@if_expr[1])
+    end
+
+    def outer_name
+      @outer.outer_name
+    end
+
+    def to_s
+      @outer.to_s
+    end
+  end
+end

data/lib/reek/method_context.rb

@@ -0,0 +1,85 @@
+require 'reek/name'
+require 'reek/code_context'
+require 'reek/object_refs'
+
+module Reek
+  class MethodContext < CodeContext
+    attr_reader :parameters
+    attr_reader :calls
+    attr_reader :refs
+    attr_reader :num_statements
+
+    def initialize(outer, exp, record = true)
+      super(outer, exp)
+      @parameters = []
+      @local_variables = []
+      @name = Name.new(exp[1])
+      @num_statements = 0
+      @calls = Hash.new(0)
+      @depends_on_self = false
+      @refs = ObjectRefs.new
+      @outer.record_method(@name)    # TODO: should be children of outer?
+    end
+
+    def count_statements(num)
+      @num_statements += num
+    end
+
+    def depends_on_instance?
+      @depends_on_self || is_overriding_method?(@name)
+    end
+
+    def has_parameter(sym)
+      @parameters.include?(sym.to_s)
+    end
+    
+    def record_call_to(exp)
+      @calls[exp] += 1
+      receiver, meth = exp[1..2]
+      if receiver.nil?
+        record_depends_on_self
+      else
+        case receiver[0]
+        when :lvar
+          @refs.record_ref(receiver) unless meth == :new
+        when :ivar
+          record_depends_on_self
+          @refs.record_reference_to_self
+        end
+      end
+    end
+    
+    def record_depends_on_self
+      @depends_on_self = true
+    end
+
+    def record_local_variable(sym)
+      @local_variables << Name.new(sym)
+    end
+
+    def self.is_block_arg?(param)
+      Array === param and param[0] == :block
+    end
+
+    def record_parameter(param)
+      @parameters << Name.new(param) unless MethodContext.is_block_arg?(param)
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+
+    def envious_receivers
+      return [] if @refs.self_is_max?
+      @refs.max_keys
+    end
+
+    def variable_names
+      @parameters + @local_variables
+    end
+  end
+end

data/lib/reek/module_context.rb

@@ -0,0 +1,34 @@
+require 'reek/code_context'
+
+module Reek
+  class ModuleContext < CodeContext
+
+    def ModuleContext.create(outer, exp)
+      res = Name.resolve(exp[1], outer)
+      ModuleContext.new(res[0], res[1])
+    end
+
+    def initialize(outer, name)
+      super(outer, nil)
+      @name = name
+    end
+
+    def myself
+      @myself ||= @outer.find_module(@name)
+    end
+
+    def find_module(modname)
+      return nil unless myself
+      sym = modname.to_s
+      myself.const_defined?(sym) ? myself.const_get(sym) : nil
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}::"
+    end
+
+    def variable_names
+      []
+    end
+  end
+end

data/lib/reek/name.rb

@@ -0,0 +1,42 @@
+module Reek
+  class Name
+    include Comparable
+
+    def self.resolve(exp, context)
+      return [context, new(exp)] unless Array === exp
+      name = exp[1]
+      case exp[0]
+      when :colon2
+        return [resolve(name, context)[0], new(exp[2])]
+      when :const
+        return [ModuleContext.create(context, exp), new(name)]
+      when :colon3
+        return [StopContext.new, new(name)]
+      else
+        return [context, new(name)]
+      end
+    end
+
+    def initialize(sym)
+      @name = sym.to_s
+    end
+
+    def hash  # :nodoc:
+      @name.hash
+    end
+
+    def <=>(other)  # :nodoc:
+      @name <=> other.to_s
+    end
+
+    alias eql? <=>
+
+    def effective_name
+      @name.gsub(/^@*/, '')
+    end
+
+    def to_s
+      @name
+    end
+  end
+end