reek 0.3.1 → 1.0.0

data/lib/reek/smells/utility_function.rb

@@ -1,6 +1,5 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -8,27 +7,28 @@ module Reek
     # 
     # A Utility Function is any instance method that has no
     # dependency on the state of the instance.
+    # 
+    # Currently +UtilityFunction+ will warn about any method that:
+    # 
+    # * is non-empty
+    # * does not override an inherited method
+    # * calls at least one method on another object
+    # * doesn't use any of self's instance variables
+    # * doesn't use any of self's methods
     #
-    class UtilityFunction < Smell
+    class UtilityFunction < SmellDetector
 
       #
       # Checks whether the given +method+ is a utility function.
-      # Any smells found are added to the +report+; returns true in that case,
-      # and false otherwise.
+      # Any smells found are added to the +report+.
       #
-      def self.examine(method, report)
-        return false if method.name == 'initialize'
-        if method.num_statements > 0 and !method.depends_on_self
-          report << new(method)
-          true
-        end
-        false
-      end
-
-      def detailed_report
-        "#{@context} doesn't depend on instance state"
+      def examine_context(method, report)
+        return false if method.calls.keys.length == 0 or
+          method.num_statements == 0 or
+          method.depends_on_instance?
+        report << SmellWarning.new(self, method,
+                      "doesn't depend on instance state")
       end
     end
-
   end
 end

data/lib/reek/source.rb

@@ -0,0 +1,116 @@
+require 'reek/code_parser'
+require 'reek/report'
+require 'reek/smells/smells'
+
+module Reek
+
+  #
+  # A +Source+ object represents a chunk of Ruby source code.
+  #
+  # The various class methods are factories that will create +Source+
+  # instances from various types of input.
+  #
+  class Source
+
+    #
+    # Factory method: creates a +Source+ object by reading Ruby code from
+    # the +IO+ stream. The stream is consumed upto end-of-file, but the
+    # source code is not parsed until +report+ is called. +desc+ provides
+    # a string description to be used in the header of formatted reports.
+    #
+    def self.from_io(ios, desc)
+      code = ios.readlines.join
+      return new(code, desc)
+    end
+
+    #
+    # Factory method: creates a +Source+ object by reading Ruby code from
+    # the +code+ string. The code is not parsed until +report+ is called.
+    #
+    def self.from_s(code)
+      return new(code, 'string')
+    end
+
+    #
+    # Factory method: creates a +Source+ object by reading Ruby code from
+    # File +file+. The source code is not parsed until +report+ is called.
+    #
+    def self.from_f(file)
+      from_path(file.path)
+    end
+
+    #
+    # Factory method: creates a +Source+ object by reading Ruby code from
+    # the named file. The source code is not parsed until +report+ is called.
+    #
+    def self.from_path(filename)
+      code = IO.readlines(filename).join
+      return new(code, filename, File.dirname(filename))
+    end
+
+    #
+    # Factory method: creates a +Source+ object from an array of file paths.
+    # No source code is actually parsed until the report is accessed.
+    #
+    def self.from_pathlist(paths)
+      sources = paths.map {|path| Source.from_path(path) }
+      SourceList.new(sources)
+    end
+
+    def initialize(code, desc, dir = '.')     # :nodoc:
+      @source = code
+      @dir = dir
+      @desc = desc
+    end
+
+    #
+    # Returns a +Report+ listing the smells found in this source. The first
+    # call to +report+ parses the source code and constructs a list of
+    # +SmellWarning+s found; subsequent calls simply return this same list.
+    #
+    def report
+      unless @report
+        @report = Report.new
+        smells = SmellConfig.new.load_local(@dir).smell_listeners
+        CodeParser.new(@report, smells).check_source(@source)
+      end
+      @report
+    end
+
+    def smelly?
+      report.length > 0
+    end
+
+    #
+    # Checks this source for instances of +smell_class+, and returns +true+
+    # only if one of them has a report string matching all of the +patterns+.
+    #
+    def has_smell?(smell_class, patterns)
+      report.any? { |smell| smell.matches?(smell_class, patterns) }
+    end
+
+    def to_s
+      @desc
+    end
+  end
+
+  #
+  # Represents a list of Sources as if they were a single source.
+  #
+  class SourceList
+    def initialize(sources)
+      @sources = sources
+    end
+
+    def smelly?
+      @sources.any? {|source| source.smelly? }
+    end
+
+    def report
+      @sources.select {|src| src.smelly? }.map do |src|
+        warnings = src.report
+        "\"#{src}\" -- #{warnings.length} warnings:\n#{warnings.to_s}\n"
+      end.join("\n")
+    end
+  end
+end

data/lib/reek/spec.rb

@@ -0,0 +1,146 @@
+require 'reek/source'
+
+module Reek
+
+  #
+  # Provides matchers for Rspec, making it easy to check code quality.
+  #
+  # If you require this module somewhere within your spec (or in your spec_helper),
+  # Reek will arrange to update Spec::Runner's config so that it knows about the
+  # matchers defined here.
+  #
+  # === Examples
+  #
+  # Here's a spec that ensures there are no smell warnings in the current project:
+  #
+  #  describe 'source code quality' do
+  #    Dir['lib/**/*.rb'].each do |path|
+  #      it "reports no smells in #{path}" do
+  #        File.new(path).should_not reek
+  #      end
+  #    end
+  #  end
+  #
+  # And here's an even simpler way to do the same:
+  #
+  #  it 'has no code smells' do
+  #    Dir['lib/**/*.rb'].should_not reek
+  #  end
+  #
+  # Here's a simple check of a code fragment:
+  #
+  #  'def equals(other) other.thing == self.thing end'.should_not reek
+  #
+  # And a more complex example, making use of one of the factory methods for
+  # +Source+ so that the code is parsed and analysed only once:
+  # 
+  #   ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'.to_source
+  #   ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
+  #   ruby.should reek_of(:Duplication, /@other.thing.foo/)
+  #   ruby.should_not reek_of(:FeatureEnvy)
+  #
+  module Spec
+    class ShouldReek        # :nodoc:
+      def matches?(actual)
+        @source = actual.to_source
+        @source.smelly?
+      end
+      def failure_message_for_should
+        "Expected source to reek, but it didn't"
+      end
+      def failure_message_for_should_not
+        "Expected no smells, but got:\n#{@source.report}"
+      end
+    end
+
+    #
+    # Returns +true+ if and only if the target source code contains smells.
+    #
+    def reek
+      ShouldReek.new
+    end
+
+    class ShouldReekOf        # :nodoc:
+      def initialize(klass, patterns)
+        @klass = klass
+        @patterns = patterns
+      end
+      def matches?(actual)
+        @source = actual.to_source
+        @source.has_smell?(@klass, @patterns)
+      end
+      def failure_message_for_should
+        "Expected #{@source} to reek of #{@klass}, but it didn't"
+      end
+      def failure_message_for_should_not
+        "Expected #{@source} not to reek of #{@klass}, but got:\n#{@source.report}"
+      end
+    end
+
+    #
+    # Checks the target source code for instances of +smell_class+,
+    # and returns +true+ only if one of them has a report string matching
+    # all of the +patterns+.
+    #
+    def reek_of(smell_class, *patterns)
+      ShouldReekOf.new(smell_class, patterns)
+    end
+
+    class ShouldReekOnlyOf        # :nodoc:
+      def initialize(klass, patterns)
+        @klass = klass
+        @patterns = patterns
+      end
+      def matches?(actual)
+        @source = actual.to_source
+        @source.report.length == 1 and @source.has_smell?(@klass, @patterns)
+      end
+      def failure_message_for_should
+        "Expected source to reek only of #{@klass}, but got:\n#{@source.report}"
+      end
+      def failure_message_for_should_not
+        "Expected source not to reek only of #{@klass}, but it did"
+      end
+    end
+
+    #
+    # As for reek_of, but the matched smell warning must be the only warning of
+    # any kind in the target source code's Reek report.
+    #
+    def reek_only_of(smell_class, *patterns)
+      ShouldReekOnlyOf.new(smell_class, patterns)
+    end
+  end
+end
+
+class File
+  def to_source
+    Reek::Source.from_f(self)
+  end
+end
+
+class String
+  def to_source
+    Reek::Source.from_s(self)
+  end
+end
+
+class Array
+  def to_source
+    Reek::Source.from_pathlist(self)
+  end
+end
+
+module Reek
+  class Source
+    def to_source
+      self
+    end
+  end
+end
+
+if Object.const_defined?(:Spec)
+  Spec::Runner.configure do |config|
+    config.include(Reek::Spec)
+  end
+end

data/lib/reek/stop_context.rb

@@ -0,0 +1,62 @@
+module Reek
+  class StopContext
+    
+    def initialize
+      @refs = ObjectRefs.new
+      @myself = Object
+    end
+
+    def count_statements(num)
+      0
+    end
+
+    def find_module(name)
+      sym = name.to_s
+      @myself.const_defined?(sym) ? @myself.const_get(sym) : nil
+    end
+
+    def has_parameter(sym)
+      false
+    end
+    
+    def inside_a_block?
+      false
+    end
+
+    def is_overriding_method?(name)
+      false
+    end
+    
+    def num_statements
+      0
+    end
+    
+    def refs
+      @refs
+    end
+    
+    def record_depends_on_self
+      false
+    end
+    
+    def record_call_to(exp)
+      nil
+    end
+
+    def record_method(name)
+    end
+
+    def record_parameter(sym)
+    end
+
+    def record_instance_variable(sym)
+    end
+
+    def record_local_variable(sym)
+    end
+    
+    def outer_name
+      ''
+    end
+  end
+end

data/lib/reek/yield_call_context.rb

@@ -0,0 +1,14 @@
+require 'reek/code_context'
+
+module Reek
+  class YieldCallContext < CodeContext
+    attr_reader :parameters
+
+    def initialize(outer, exp)
+      super
+      @parameters = []
+      args = exp[1]
+      @parameters = args[0...-1] if args
+    end
+  end
+end

data/reek.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{reek}
+  s.version = "0.3.1.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kevin Rutherford"]
+  s.date = %q{2009-04-03}
+  s.default_executable = %q{reek}
+  s.description = %q{Code smell detector for Ruby}
+  s.email = ["kevin@rutherford-software.com"]
+  s.executables = ["reek"]
+  s.extra_rdoc_files = ["History.txt", "README.txt"]
+  s.files = ["History.txt", "README.txt", "Rakefile", "bin/reek", "config/defaults.reek", "lib/reek.rb", "lib/reek/block_context.rb", "lib/reek/class_context.rb", "lib/reek/code_context.rb", "lib/reek/code_parser.rb", "lib/reek/exceptions.reek", "lib/reek/if_context.rb", "lib/reek/method_context.rb", "lib/reek/module_context.rb", "lib/reek/name.rb", "lib/reek/object_refs.rb", "lib/reek/options.rb", "lib/reek/rake_task.rb", "lib/reek/report.rb", "lib/reek/sexp_formatter.rb", "lib/reek/singleton_method_context.rb", "lib/reek/smell_warning.rb", "lib/reek/smells/control_couple.rb", "lib/reek/smells/duplication.rb", "lib/reek/smells/feature_envy.rb", "lib/reek/smells/large_class.rb", "lib/reek/smells/long_method.rb", "lib/reek/smells/long_parameter_list.rb", "lib/reek/smells/long_yield_list.rb", "lib/reek/smells/nested_iterators.rb", "lib/reek/smells/smell_detector.rb", "lib/reek/smells/smells.rb", "lib/reek/smells/uncommunicative_name.rb", "lib/reek/smells/utility_function.rb", "lib/reek/source.rb", "lib/reek/spec.rb", "lib/reek/stop_context.rb", "lib/reek/yield_call_context.rb", "reek.gemspec", "spec/integration/reek_source_spec.rb", "spec/integration/script_spec.rb", "spec/reek/class_context_spec.rb", "spec/reek/code_context_spec.rb", "spec/reek/code_parser_spec.rb", "spec/reek/config_spec.rb", "spec/reek/if_context_spec.rb", "spec/reek/method_context_spec.rb", "spec/reek/module_context_spec.rb", "spec/reek/object_refs_spec.rb", "spec/reek/options_spec.rb", "spec/reek/report_spec.rb", "spec/reek/sexp_formatter_spec.rb", "spec/reek/singleton_method_context_spec.rb", "spec/reek/smells/control_couple_spec.rb", "spec/reek/smells/duplication_spec.rb", "spec/reek/smells/feature_envy_spec.rb", "spec/reek/smells/large_class_spec.rb", "spec/reek/smells/long_method_spec.rb", "spec/reek/smells/long_parameter_list_spec.rb", "spec/reek/smells/nested_iterators_spec.rb", "spec/reek/smells/smell_spec.rb", "spec/reek/smells/uncommunicative_name_spec.rb", "spec/reek/smells/utility_function_spec.rb", "spec/samples/inline.rb", "spec/samples/inline_spec.rb", "spec/samples/optparse.rb", "spec/samples/optparse_spec.rb", "spec/samples/redcloth.rb", "spec/samples/redcloth_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/reek.rake", "tasks/rspec.rake"]
+  s.has_rdoc = true
+  s.homepage = %q{http://wiki.github.com/kevinrutherford/reek}
+  s.post_install_message = %q{
+For more information on reek, see http://wiki.github.com/kevinrutherford/reek
+}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{reek}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Code smell detector for Ruby}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ParseTree>, ["~> 3.0"])
+      s.add_runtime_dependency(%q<sexp_processor>, ["~> 3.0"])
+    else
+      s.add_dependency(%q<ParseTree>, ["~> 3.0"])
+      s.add_dependency(%q<sexp_processor>, ["~> 3.0"])
+    end
+  else
+    s.add_dependency(%q<ParseTree>, ["~> 3.0"])
+    s.add_dependency(%q<sexp_processor>, ["~> 3.0"])
+  end
+end

data/spec/integration/reek_source_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe 'Reek source code:' do
+  Dir['lib/**/*.rb'].each do |path|
+    it "reports no smells in #{path}" do
+      File.new(path).should_not reek
+    end
+  end
+
+  it 'reports no smells via the Dir matcher' do
+    Dir['lib/**/*.rb'].should_not reek
+  end
+end
+
+describe 'RakeTask' do
+  it 'should report no duplication' do
+    report = `rake reek`.split("\n")
+    report.length.should == 1
+  end
+end