kevinrutherford-reek 0.3.1.4

data/lib/reek/smells/long_parameter_list.rb

@@ -0,0 +1,43 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # A Long Parameter List occurs when a method has more than one
+    # or two parameters, or when a method yields more than one or
+    # two objects to an associated block.
+    #
+    # Currently +LongParameterList+ reports any method or block with too
+    # many parameters.
+    #
+    class LongParameterList < SmellDetector
+
+      # The name of the config field that sets the maximum number of
+      # parameters permitted in any method or block.
+      MAX_ALLOWED_PARAMS_KEY = 'max_params'
+
+      def self.default_config
+        super.adopt(MAX_ALLOWED_PARAMS_KEY => 3)
+      end
+
+      def initialize(config)
+        super
+        @max_params = config['max_params']
+        @action = 'has'
+      end
+      
+      #
+      # Checks the number of parameters in the given scope.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(ctx, report)
+        num_params = ctx.parameters.length
+        return false if num_params <= @max_params
+        report << SmellWarning.new(self, ctx,
+                    "#{@action} #{num_params} parameters")
+      end
+    end
+  end
+end

data/lib/reek/smells/long_yield_list.rb

@@ -0,0 +1,18 @@
+require 'reek/smells/smell_detector'
+
+module Reek
+  module Smells
+
+    class LongYieldList < LongParameterList
+
+      def self.contexts      # :nodoc:
+        [:yield]
+      end
+
+      def initialize(config)
+        super
+        @action = 'yields'
+      end
+    end
+  end
+end

data/lib/reek/smells/nested_iterators.rb

@@ -0,0 +1,28 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # A Nested Iterator occurs when a block contains another block.
+    #
+    # +NestedIterators+ reports failing methods only once.
+    #
+    class NestedIterators < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:iter]
+      end
+
+      #
+      # Checks whether the given +block+ is inside another.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(block, report)
+        return false unless block.nested_block?
+        report << SmellWarning.new(self, block, 'is nested')
+      end
+    end
+  end
+end

data/lib/reek/smells/smell_detector.rb

@@ -0,0 +1,66 @@
+class Class
+  def name_words
+    class_name = name.split(/::/)[-1]
+    class_name.gsub(/([a-z])([A-Z])/) { |sub| "#{$1} #{$2}"}.split
+  end
+end
+
+module Reek
+  module Smells
+
+    class SmellDetector
+
+      # The name of the config field that lists the names of code contexts
+      # that should not be checked. Add this field to the config for each
+      # smell that should ignore this code element.
+      EXCLUDE_KEY = 'exclude'
+
+      # The name fo the config field that specifies whether a smell is
+      # enabled. Set to +true+ or +false+.
+      ENABLED_KEY = 'enabled'
+      
+      def self.class_name
+        self.name.split(/::/)[-1]
+      end
+
+      def self.contexts      # :nodoc:
+        [:defn, :defs]
+      end
+      
+      def self.default_config
+        {
+          ENABLED_KEY => true,
+          EXCLUDE_KEY => []
+        }
+      end
+
+      def self.listen(hooks, config)
+        detector = new(config[class_name])
+        contexts.each { |ctx| hooks[ctx] << detector }
+      end
+
+      def initialize(config)
+        @enabled = config[ENABLED_KEY]
+        @exceptions = config[EXCLUDE_KEY]
+      end
+
+      def examine(context, report)
+        before = report.size
+        examine_context(context, report) if @enabled and !exception?(context)
+        report.length > before
+      end
+
+      def examine_context(context, report)
+      end
+      
+      def exception?(context)
+        return false if @exceptions.nil? or @exceptions.length == 0
+        context.matches?(@exceptions)
+      end
+
+      def smell_name
+        self.class.name_words.join(' ')
+      end
+    end
+  end
+end

data/lib/reek/smells/smells.rb

@@ -0,0 +1,85 @@
+require 'reek/smells/control_couple'
+require 'reek/smells/duplication'
+require 'reek/smells/feature_envy'
+require 'reek/smells/large_class'
+require 'reek/smells/long_method'
+require 'reek/smells/long_parameter_list'
+require 'reek/smells/long_yield_list'
+require 'reek/smells/nested_iterators'
+require 'reek/smells/uncommunicative_name'
+require 'reek/smells/utility_function'
+require 'yaml'
+
+class Hash
+  def value_merge!(other)
+    other.keys.each do |key|
+      self[key].adopt!(other[key])
+    end
+    self
+  end
+  
+  def adopt!(other)
+    other.keys.each do |key|
+      ov = other[key]
+      if Array === ov and has_key?(key)
+        self[key] += ov
+      else
+        self[key] = ov
+      end
+    end
+    self
+  end
+  
+  def adopt(other)
+    self.deep_copy.adopt!(other)
+  end
+  
+  def deep_copy
+    YAML::load(YAML::dump(self))
+  end
+end
+
+module Reek
+  class SmellConfig
+
+    SMELL_CLASSES = [
+      Smells::ControlCouple,
+      Smells::Duplication,
+      Smells::FeatureEnvy,
+      Smells::LargeClass,
+      Smells::LongMethod,
+      Smells::LongParameterList,
+      Smells::LongYieldList,
+      Smells::NestedIterators,
+      Smells::UncommunicativeName,
+      Smells::UtilityFunction,
+    ]
+
+    def initialize
+      defaults_file = File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'defaults.reek')
+      @config = YAML.load_file(defaults_file)
+    end
+
+    def smell_listeners()
+      result = Hash.new {|hash,key| hash[key] = [] }
+      SMELL_CLASSES.each { |smell| smell.listen(result, @config) }
+      return result
+    end
+
+    def load_local(file)
+      path = File.expand_path(file)
+      all_reekfiles(path).each do |rfile|
+        cf = YAML.load_file(rfile)
+        @config.value_merge!(cf)
+      end
+      self
+    end
+
+    def all_reekfiles(path)
+      return [] unless File.exist?(path)
+      parent = File.dirname(path)
+      return [] if path == parent
+      all_reekfiles(parent) + Dir["#{path}/*.reek"]
+    end
+  end
+end

data/lib/reek/smells/uncommunicative_name.rb

@@ -0,0 +1,80 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # An Uncommunicative Name is a name that doesn't communicate its intent
+    # well enough.
+    # 
+    # Poor names make it hard for the reader to build a mental picture
+    # of what's going on in the code. They can also be mis-interpreted;
+    # and they hurt the flow of reading, because the reader must slow
+    # down to interpret the names.
+    #
+    # Currently +UncommunicativeName+ checks for
+    # * 1-character names
+    # * names consisting of a single character followed by a number
+    #
+    class UncommunicativeName < SmellDetector
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be rejected.
+      REJECT_KEY = 'reject'
+      
+      # The name of the config field that lists the specific names that are
+      # to be treated as exceptions; these names will not be reported as
+      # uncommunicative.
+      ACCEPT_KEY = 'accept'
+
+      def self.default_config
+        super.adopt(
+          REJECT_KEY => [/^.[0-9]*$/],
+          ACCEPT_KEY => ['Inline::C']
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:module, :class, :defn, :defs, :iter]
+      end
+
+      def initialize(config = UncommunicativeName.default_config)
+        super
+        @reject = config[REJECT_KEY]
+        @accept = config[ACCEPT_KEY]
+      end
+
+      #
+      # Checks the given +context+ for uncommunicative names.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(context, report)
+        consider_name(context, report)
+        consider_variables(context, report)
+      end
+
+      def consider_variables(context, report) # :nodoc:
+        context.variable_names.each do |name|
+          next unless is_bad_name?(name)
+          report << SmellWarning.new(self, context,
+                      "has the variable name '#{name}'")
+        end
+      end
+
+      def consider_name(context, report)  # :nodoc:
+        name = context.name
+        return false if @accept.include?(context.to_s)  # TODO: fq_name() ?
+        return false unless is_bad_name?(name)
+        report << SmellWarning.new(self, context,
+                      "has the name '#{name}'")
+      end
+
+      def is_bad_name?(name)  # :nodoc:
+        var = name.effective_name
+        return false if var == '*' or @accept.include?(var)
+        @reject.detect {|patt| patt === var}
+      end
+    end
+  end
+end

data/lib/reek/smells/utility_function.rb

@@ -0,0 +1,34 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    # 
+    # 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 < SmellDetector
+
+      #
+      # Checks whether the given +method+ is a utility function.
+      # Any smells found are added to the +report+.
+      #
+      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,130 @@
+require 'reek/source'
+
+module Reek
+
+  #
+  # Provides matchers for Rspec, making it easy to check code quality.
+  #
+  # === 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
+  #
+  # 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

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/lib/reek.rb

@@ -0,0 +1,8 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/report'
+require 'reek/smells/smells'
+
+module Reek # :doc:
+  VERSION = '0.3.1.4'
+end