teksymmetry-reek 1.1.3.1

data/lib/reek/source.rb

@@ -0,0 +1,127 @@
+require 'reek/code_parser'
+require 'reek/report'
+require 'reek/smells/smells'
+require 'ruby_parser'
+
+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 = nil)     # :nodoc:
+      @source = code
+      @desc = desc
+      @cf = SmellConfig.new
+      @cf = @cf.load_local(dir) if dir
+    end
+
+    def generate_syntax_tree
+      RubyParser.new.parse(@source, @desc) || s()
+    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
+        parser = CodeParser.new(@report, @cf.smell_listeners)
+        parser.process(generate_syntax_tree)
+      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
+
+    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+    # this report, with a heading.
+    def full_report
+      report.full_report(@desc)
+    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
+      ReportList.new(@sources)
+    end
+  end
+end
+
+require 'reek/object_source'

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,50 @@
+module Reek
+  class StopContext
+    
+    def initialize
+      @refs = ObjectRefs.new
+      @myself = Object
+    end
+    def method_missing(method, *args)
+      nil
+    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 outer_name
+      ''
+    end
+  end
+end

data/lib/reek/yield_call_context.rb

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

data/lib/reek.rb

@@ -0,0 +1,7 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/verifier_extension_manager'
+
+module Reek # :doc:
+  VERSION = '1.1.3.1'
+end

data/reek.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{reek}
+  s.version = "1.1.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kevin Rutherford"]
+  s.date = %q{2009-06-04}
+  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/object_source.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/reek/block_context_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/name_spec.rb", "spec/reek/object_refs_spec.rb", "spec/reek/options_spec.rb", "spec/reek/report_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/slow/inline_spec.rb", "spec/slow/optparse_spec.rb", "spec/slow/redcloth_spec.rb", "spec/slow/reek_source_spec.rb", "spec/slow/samples/inline.rb", "spec/slow/samples/optparse.rb", "spec/slow/samples/redcloth.rb", "spec/slow/script_spec.rb", "spec/slow/source_list_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/reek.rake", "tasks/rspec.rake"]
+  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.3}
+  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 = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ruby_parser>, ["~> 2.0"])
+      s.add_runtime_dependency(%q<ruby2ruby>, ["~> 1.2"])
+      s.add_runtime_dependency(%q<sexp_processor>, ["~> 3.0"])
+    else
+      s.add_dependency(%q<ruby_parser>, ["~> 2.0"])
+      s.add_dependency(%q<ruby2ruby>, ["~> 1.2"])
+      s.add_dependency(%q<sexp_processor>, ["~> 3.0"])
+    end
+  else
+    s.add_dependency(%q<ruby_parser>, ["~> 2.0"])
+    s.add_dependency(%q<ruby2ruby>, ["~> 1.2"])
+    s.add_dependency(%q<sexp_processor>, ["~> 3.0"])
+  end
+end

data/spec/reek/block_context_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/block_context'
+require 'reek/method_context'
+
+include Reek
+
+describe BlockContext do
+
+  it "should record single parameter" do
+    element = StopContext.new
+    element = BlockContext.new(element, s(s(:lasgn, :x), nil))
+    element.variable_names.should == [Name.new(:x)]
+  end
+
+  it "should record single parameter within a method" do
+    element = StopContext.new
+    element = MethodContext.new(element, s(:defn, :help))
+    element = BlockContext.new(element, s(s(:lasgn, :x), nil))
+    element.variable_names.should == [Name.new(:x)]
+  end
+
+  it "records multiple parameters" do
+    element = StopContext.new
+    element = BlockContext.new(element, s(s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))), nil))
+    element.variable_names.should == [Name.new(:x), Name.new(:y)]
+  end
+
+  it "should not pass parameters upward" do
+    mc = MethodContext.new(StopContext.new, s(:defn, :help))
+    element = BlockContext.new(mc, s(s(:lasgn, :x)))
+    mc.variable_names.should be_empty
+  end
+
+  it 'records local variables' do
+    bctx = BlockContext.new(StopContext.new, nil)
+    bctx.record_local_variable(:q2)
+    bctx.variable_names.should include(Name.new(:q2))
+  end
+end

data/spec/reek/class_context_spec.rb

@@ -0,0 +1,169 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/class_context'
+require 'reek/stop_context'
+require 'reek/smells/feature_envy'
+
+include Reek
+include Reek::Smells
+
+describe ClassContext do
+  it 'should report Long Parameter List' do
+    ruby = 'class Inner; def simple(arga, argb, argc, argd) f(3);true end end'
+    ruby.should reek_of(:LongParameterList, /Inner/, /simple/, /4 parameters/)
+  end
+
+  it 'should report two different methods' do
+    src = <<EOEX
+class Fred
+  def simple(arga, argb, argc, argd) f(3);true end
+  def simply(arga, argb, argc, argd) f(3);false end
+end
+EOEX
+    src.should reek_of(:LongParameterList, /Fred/, /simple/)
+    src.should reek_of(:LongParameterList, /Fred/, /simply/)
+  end
+
+  it 'should report many different methods' do
+    src = <<EOEX
+class Fred
+    def textile_bq(tag, atts, cite, content) f(3);end
+    def textile_p(tag, atts, cite, content) f(3);end
+    def textile_fn_(tag, num, atts, cite, content) f(3);end
+    def textile_popup_help(name, windowW, windowH) f(3);end
+end
+EOEX
+    src.should reek_of(:LongParameterList, /Fred/, /textile_bq/)
+    src.should reek_of(:LongParameterList, /Fred/, /textile_fn_/)
+    src.should reek_of(:LongParameterList, /Fred/, /textile_p/)
+  end
+end
+
+describe ClassContext, 'overridden methods' do
+  class Above
+    def above() end
+    def both() end
+  end
+  
+  class Below < Above
+    def both() end
+    def below() end
+  end
+  
+  describe 'of loaded class' do
+    before :each do
+      @ctx = ClassContext.create(StopContext.new, [0, :Below])
+    end
+
+    it 'should recognise non-overridden method' do
+      @ctx.is_overriding_method?('below').should == false
+      @ctx.is_overriding_method?('above').should == false
+    end
+
+    it 'should recognise overridden method' do
+      @ctx.is_overriding_method?('both').should == true
+    end
+    
+    it 'should recognise methods in current codebase' do
+      ctx = ClassContext.create(StopContext.new, [0, :FeatureEnvy])
+      ctx.is_overriding_method?('examine_context').should == true
+    end
+  end
+  
+  describe 'of non-loaded class' do
+    before :each do
+      @ctx = ClassContext.create(StopContext.new, [0, :Missing])
+    end
+
+    it 'should recognise non-overridden method' do
+      @ctx.is_overriding_method?('below').should == false
+      @ctx.is_overriding_method?('above').should == false
+    end
+
+    it 'should recognise overridden method' do
+      @ctx.is_overriding_method?('both').should == false
+    end
+  end
+end
+
+describe 'Integration defect:' do
+  it 'should not report UtilityFunction for FeatureEnvy#examine_context' do
+    kelement = ClassContext.create(StopContext.new, [0, :FeatureEnvy, s(:const, :SmellDetector)])
+    meth = Name.new(:examine_context)
+    kelement.is_overriding_method?(meth).should == true
+    melement = MethodContext.new(kelement, [0, :examine_context])
+    melement.is_overriding_method?(meth).should == true
+    melement.depends_on_instance?.should == true
+  end
+end
+
+describe CodeContext, 'find class' do
+  module Mod1
+    class Klass1
+      module Mod2
+        class Klass2
+        end
+      end
+    end
+  end
+
+  before :each do
+    @stop = StopContext.new
+    @mod1 = ModuleContext.create(@stop, [0, :Mod1])
+    @klass1 = ClassContext.create(@mod1, [0, :Klass1])
+    @mod2 = ModuleContext.create(@klass1, [0, :Mod2])
+    @klass2 = ClassContext.create(@mod2, [0, :Klass2])
+  end
+
+  describe StopContext do
+    it 'should not find unqualified class' do
+      @stop.find_module('Klass2').should == nil
+    end
+
+    it 'should find unqualified module' do
+      @stop.find_module('Mod1').name.should == 'Mod1'
+    end
+  end
+  
+  describe ModuleContext do
+    it 'should find local name' do
+      @mod1.find_module('Klass1').name.should == 'Mod1::Klass1'
+      @mod2.find_module('Klass2').name.should == 'Mod1::Klass1::Mod2::Klass2'
+    end
+    
+    it 'should not find deeper class' do
+      @mod1.find_module('Klass2').should == nil
+    end
+    
+    it 'should find own Module' do
+      @mod1.myself.name.should == 'Mod1'
+      @mod2.myself.name.should == 'Mod1::Klass1::Mod2'
+    end
+  end
+  
+  describe ClassContext do
+    it 'should find local module' do
+      @klass1.find_module('Mod2').name.should == 'Mod1::Klass1::Mod2'
+    end
+    
+    it 'should not find deeper module' do
+      @klass1.find_module('Klass2').should == nil
+    end
+    
+    it 'should find own Class' do
+      @klass1.myself.name.should == 'Mod1::Klass1'
+      @klass2.myself.name.should == 'Mod1::Klass1::Mod2::Klass2'
+    end
+  end
+end
+
+describe ClassContext do
+  it 'should not report empty class in another module' do
+    'class Treetop::Runtime::SyntaxNode; end'.should_not reek
+  end
+
+  it 'should deal with :: scoped names' do
+    element = ClassContext.create(StopContext.new, [:colon2, [:colon2, [:const, :Treetop], :Runtime], :SyntaxNode])
+    element.num_methods.should == 0
+  end
+end

data/spec/reek/code_context_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'reek/block_context'
+require 'reek/if_context'
+require 'reek/class_context'
+require 'reek/module_context'
+require 'reek/method_context'
+require 'reek/stop_context'
+
+include Reek
+
+describe CodeContext, 'to_s' do
+
+  it "should report full context" do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element = ClassContext.new(element, [0, :klass])
+    element = MethodContext.new(element, [0, :bad])
+    element = BlockContext.new(element, nil)
+    element.to_s.should match(/bad/)
+    element.to_s.should match(/klass/)
+    element.to_s.should match(/mod/)
+  end
+
+  it "should report method name via if context" do
+    element1 = StopContext.new
+    element2 = MethodContext.new(element1, [0, :bad])
+    element3 = IfContext.new(element2, [0,1])
+    BlockContext.new(element3, nil).to_s.should match(/bad/)
+  end
+
+  it "should report method name via nested blocks" do
+    element1 = StopContext.new
+    element2 = MethodContext.new(element1, [0, :bad])
+    element3 = BlockContext.new(element2, nil)
+    BlockContext.new(element3, nil).to_s.should match(/bad/)
+  end
+end
+
+describe CodeContext, 'instance variables' do
+  it 'should pass instance variables down to the first class' do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    class_element = ClassContext.new(element, [0, :klass])
+    element = MethodContext.new(class_element, [0, :bad])
+    element = BlockContext.new(element, nil)
+    element.record_instance_variable(:fred)
+    class_element.variable_names.size.should == 1
+    class_element.variable_names.should include(Name.new(:fred))
+  end
+end
+
+describe CodeContext, 'generics' do
+  it 'should pass unknown method calls down the stack' do
+    stop = StopContext.new
+    def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
+    element = ModuleContext.new(stop, [0, :mod])
+    class_element = ClassContext.new(element, [0, :klass])
+    element = MethodContext.new(class_element, [0, :bad])
+    element = BlockContext.new(element, nil)
+    element.bananas(17, -5).should == 55
+  end
+end
+
+describe CodeContext do
+  it 'should recognise itself in a collection of names' do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element.matches?(['banana', 'mod']).should == true
+  end
+
+  it 'should recognise itself in a collection of REs' do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element.matches?([/banana/, /mod/]).should == true
+  end
+
+  it 'should recognise its fq name in a collection of names' do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element = ClassContext.create(element, [0, :klass])
+    element.matches?(['banana', 'mod']).should == true
+    element.matches?(['banana', 'mod::klass']).should == true
+  end
+
+  it 'should recognise its fq name in a collection of names' do
+    element = StopContext.new
+    element = ModuleContext.new(element, [0, :mod])
+    element = ClassContext.create(element, [0, :klass])
+    element.matches?([/banana/, /mod/]).should == true
+    element.matches?([/banana/, /mod::klass/]).should == true
+  end
+end