reek 0.3.1 → 1.0.0

data/History.txt

@@ -1,3 +1,23 @@
+== 1.0.0 2009-04-05
+
+=== Major enhancements:
+
+* Use *.reek files in source tree to configure Reek's 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
+
 == 0.3.1 2008-11-17
 
 * Minor enhancements:

data/README.txt

@@ -1,82 +1,6 @@
-= reek
+= Reek
 
-* http://rubyforge.org/projects/reek/
-* mailto:kevin@rutherford-software.com
+Code smell detection for Ruby.
 
-== DESCRIPTION:
-
-Reek is a tool that examines Ruby classes, modules and methods and
-reports any code smells it finds.
-
-=== SUPPORTED CODE SMELLS:
-
-Reek currently includes very naive checks for the following smells:
-
-* Long Method
-* Large Class
-* Feature Envy
-* Uncommunicative Name
-* Long Parameter List
-* Utility Function
-* Nested Iterators
-* Control Couple
-* Duplication
-
-== FEATURES/PROBLEMS:
-
-* Most of the current checks are quite naive.
-* 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:
-
-  $ reek [options] sources
-
-(See `reek --help` for details.)
-
-== DEPENDENCIES:
-
-Reek makes use of the following other gems:
-
-* ParseTree
-* sexp_processor
-
-== INSTALL:
-
-Get the latest version of the gem:
-
-    $ gem install reek
-
-Or get the latest source code from:
-
-    $ git clone git://github.com/kevinrutherford/reek.git
-
-or
-
-    $ git clone git://rubyforge.org/reek.git
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2008 Kevin Rutherford, Rutherford Software Ltd
-
-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.
+The documentation is at http://wiki.github.com/kevinrutherford/reek
+The code lives at http://github.com/kevinrutherford/reek/tree

data/Rakefile

@@ -1,6 +1,17 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
+require 'rake'
+require 'rake/clean'
 
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+$:.unshift File.dirname(__FILE__) + '/lib'
 
-task :default => :spec
+PROJECT_NAME = 'reek'
+
+BUILD_DIR = 'build'; directory BUILD_DIR
+PKG_DIR = "#{BUILD_DIR}/pkg"; directory PKG_DIR
+RDOC_DIR = "#{BUILD_DIR}/rdoc"; directory RDOC_DIR
+
+GEM_MANIFEST = "Manifest.txt"
+VERSION_FILE = 'lib/reek.rb'
+
+CLOBBER.include("#{BUILD_DIR}/*")
+
+Dir['tasks/**/*.rake'].each { |t| load t }

data/bin/reek

@@ -1,25 +1,19 @@
 #!/usr/bin/env ruby
 #
-#  Created on 2008-2-17.
-#  Copyright (c) 2008 Kevin Rutherford, Rutherford Software Ltd. All rights reserved.
+# Reek examines Ruby source code for smells.
+# Visit http://reek.rubyforge.org/ for docs etc.
+#
+# Author: Kevin Rutherford
 #
 
-require File.join(File.dirname(__FILE__), '../lib/', 'reek')
-require File.join(File.dirname(__FILE__), '../lib/', 'reek/options')
+require 'reek'
+require 'reek/source'
+require 'reek/options'
 
-sources = Reek::Options.parse(ARGV)
 exitstatus = 0
-sources.each do |src|
-  smells = Reek.analyse(src)
-  next if smells.empty?
-  if sources.size == 1
-    puts smells.to_s
-  else
-    puts "\"#{src}\" -- #{smells.length} warnings:"
-    puts smells.to_s
-    puts
-  end
+source = Reek::Options.parse(ARGV)
+if source.smelly?
+  puts source.report
   exitstatus = 2
 end
-
 exit(exitstatus)

data/config/defaults.reek

@@ -0,0 +1,53 @@
+--- 
+LargeClass: 
+  max_methods: 25
+  exclude: 
+  - Array
+  - Hash
+  - Module
+  - String
+  enabled: true
+LongParameterList: 
+  max_params: 3
+  exclude: []
+
+  enabled: true
+FeatureEnvy: 
+  exclude: 
+  - initialize
+  enabled: true
+UncommunicativeName: 
+  accept: 
+  - Inline::C
+  exclude: []
+
+  enabled: true
+  reject: 
+  - !ruby/regexp /^.[0-9]*$/
+NestedIterators: 
+  exclude: []
+
+  enabled: true
+LongMethod: 
+  max_statements: 5
+  exclude: 
+  - initialize
+  enabled: true
+Duplication: 
+  exclude: []
+
+  enabled: true
+  max_calls: 1
+UtilityFunction: 
+  exclude: []
+
+  enabled: true
+ControlCouple: 
+  exclude: 
+  - initialize
+  enabled: true
+LongYieldList: 
+  max_params: 3
+  exclude: []
+
+  enabled: true

data/lib/reek.rb

@@ -1,25 +1,5 @@
 $:.unshift File.dirname(__FILE__)
 
-require 'reek/file_checker'
-require 'reek/report'
-
 module Reek # :doc:
-
-  #
-  # Analyse the given source, looking for code smells.
-  # The source can be a filename or a String containing Ruby code.
-  # Returns a +Report+ listing the smells found.
-  #
-  def self.analyse(src)  # :doc:
-    report = Report.new
-    source = Reek.get_source(src)
-    FileChecker.new(report).check_source(source)
-    report
-  end
-
-private
-
-  def self.get_source(src)
-    File.exists?(src) ? IO.readlines(src).join : src
-  end
+  VERSION = '1.0.0'
 end

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