teksymmetry-reek 1.1.3.1

data/lib/reek/smells/control_couple.rb

@@ -0,0 +1,61 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
+
+module Reek
+  module Smells
+
+    #
+    # Control Coupling occurs when a method or block checks the value of
+    # a parameter in order to decide which execution path to take. The
+    # offending parameter is often called a Control Couple.
+    # 
+    # A simple example would be the <tt>quoted</tt> parameter
+    # in the following method:
+    # 
+    #  def write(quoted)
+    #    if quoted
+    #      write_quoted(@value)
+    #    else
+    #      puts @value
+    #    end
+    #  end
+    # 
+    # Control Coupling is a kind of duplication, because the calling method
+    # already knows which path should be taken.
+    # 
+    # Control Coupling reduces the code's flexibility by creating a
+    # dependency between the caller and callee:
+    # any change to the possible values of the controlling parameter must
+    # be reflected on both sides of the call.
+    # 
+    # A Control Couple also reveals a loss of simplicity: the called
+    # method probably has more than one responsibility,
+    # because it includes at least two different code paths.
+    #
+    class ControlCouple < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:if]
+      end
+
+      def self.default_config
+        super.adopt(EXCLUDE_KEY => ['initialize'])
+      end
+
+      def initialize(config = ControlCouple.default_config)
+        super
+      end
+
+      #
+      # Checks whether the given conditional statement relies on a control couple.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(cond, report)
+        return unless cond.tests_a_parameter?
+        report << SmellWarning.new(self, cond,
+                    "is controlled by argument #{SexpFormatter.format(cond.if_expr)}")
+      end
+    end
+  end
+end

data/lib/reek/smells/duplication.rb

@@ -0,0 +1,50 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
+
+module Reek
+  module Smells
+
+    #
+    # Duplication occurs when two fragments of code look nearly identical,
+    # or when two fragments of code have nearly identical effects
+    # at some conceptual level.
+    # 
+    # Currently +Duplication+ checks for repeated identical method calls
+    # within any one method definition. For example, the following method
+    # will report a warning:
+    # 
+    #   def double_thing()
+    #     @other.thing + @other.thing
+    #   end
+    #
+    class Duplication < SmellDetector
+
+      # The name of the config field that sets the maximum number of
+      # identical calls to be permitted within any single method.
+      MAX_ALLOWED_CALLS_KEY = 'max_calls'
+
+      def self.default_config
+        super.adopt(MAX_ALLOWED_CALLS_KEY => 1)
+      end
+
+      def initialize(config = Duplication.default_config)
+        super
+        @max_calls = config[MAX_ALLOWED_CALLS_KEY]
+      end
+
+      def examine_context(method, report)
+        smelly_calls(method).each do |call|
+          report << SmellWarning.new(self, method,
+                      "calls #{SexpFormatter.format(call)} multiple times")
+        end
+      end
+      
+      def smelly_calls(method)   # :nodoc:
+        method.calls.select do |key,val|
+          val > @max_calls and key[2] != :new
+        end.map { |call_exp| call_exp[0] }
+      end
+    end
+  end
+end

data/lib/reek/smells/feature_envy.rb

@@ -0,0 +1,58 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
+
+module Reek
+  module Smells
+
+    #
+    # Feature Envy occurs when a code fragment references another object
+    # more often than it references itself, or when several clients do
+    # the same series of manipulations on a particular type of object.
+    # 
+    # A simple example would be the following method, which "belongs"
+    # on the Item class and not on the Cart class:
+    # 
+    #  class Cart
+    #    def price
+    #      @item.price + @item.tax
+    #    end
+    #  end
+    #
+    # Feature Envy reduces the code's ability to communicate intent:
+    # code that "belongs" on one class but which is located in another
+    # can be hard to find, and may upset the "System of Names"
+    # in the host class.
+    # 
+    # Feature Envy also affects the design's flexibility: A code fragment
+    # that is in the wrong class creates couplings that may not be natural
+    # within the application's domain, and creates a loss of cohesion
+    # in the unwilling host class.
+    # 
+    # Currently +FeatureEnvy+ reports any method that refers to self less
+    # often than it refers to (ie. send messages to) some other object.
+    #
+    class FeatureEnvy < SmellDetector
+
+      def self.default_config
+        super.adopt(EXCLUDE_KEY => ['initialize'])
+      end
+
+      def initialize(config = FeatureEnvy.default_config)
+        super
+      end
+
+      #
+      # Checks whether the given +context+ includes any code fragment that
+      # might "belong" on another class.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(context, report)
+        context.envious_receivers.each do |ref|
+          report << SmellWarning.new(self, context,
+                      "refers to #{SexpFormatter.format(ref)} more than self")
+        end
+      end
+    end
+  end
+end

data/lib/reek/smells/large_class.rb

@@ -0,0 +1,69 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # A Large Class is a class or module that has a large number of
+    # instance variables, methods or lines of code.
+    # 
+    # Currently +LargeClass+ only reports classes having more than a
+    # configurable number of methods or instance variables. The method count
+    # includes public, protected and
+    # private methods, and excludes methods inherited from superclasses or
+    # included modules.
+    #
+    class LargeClass < SmellDetector
+
+      # The name of the config field that sets the maximum number of methods
+      # permitted in a class.
+      MAX_ALLOWED_METHODS_KEY = 'max_methods'
+
+      # The name of the config field that sets the maximum number of instance
+      # variables permitted in a class.
+      MAX_ALLOWED_IVARS_KEY = 'max_instance_variables'
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_METHODS_KEY => 25,
+          MAX_ALLOWED_IVARS_KEY => 9,
+          EXCLUDE_KEY => []
+          )
+      end
+
+      def initialize(config = LargeClass.default_config)
+        super
+        @max_methods = config[MAX_ALLOWED_METHODS_KEY]
+        @max_instance_variables = config[MAX_ALLOWED_IVARS_KEY]
+      end
+
+      def check_num_methods(klass, report)  # :nodoc:
+        count = klass.num_methods
+        return if count <= @max_methods
+        report << SmellWarning.new(self, klass,
+                    "has at least #{count} methods")
+      end
+
+      def check_num_ivars(klass, report)  # :nodoc:
+        count = klass.variable_names.length
+        return if count <= @max_instance_variables
+        report << SmellWarning.new(self, klass,
+                    "has at least #{count} instance variables")
+      end
+
+      #
+      # Checks +klass+ for too many methods or too many instance variables.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(klass, report)
+        check_num_methods(klass, report)
+        check_num_ivars(klass, report)
+      end
+    end
+  end
+end

data/lib/reek/smells/long_method.rb

@@ -0,0 +1,43 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # A Long Method is any method that has a large number of lines.
+    #
+    # Currently +LongMethod+ reports any method with more than
+    # 5 statements.
+    #
+    class LongMethod < SmellDetector
+
+      # The name of the config field that sets the maximum number of
+      # statements permitted in any method.
+      MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'
+
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_STATEMENTS_KEY => 5,
+          EXCLUDE_KEY => ['initialize']
+        )
+      end
+
+      def initialize(config = LongMethod.default_config)
+        super
+        @max_statements = config[MAX_ALLOWED_STATEMENTS_KEY]
+      end
+
+      #
+      # Checks the length of the given +method+.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(method, report)
+        num = method.num_statements
+        return false if num <= @max_statements
+        report << SmellWarning.new(self, method,
+                    "has approx #{num} statements")
+      end
+    end
+  end
+end

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,81 @@
+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 push_keys(hash)
+    keys.each {|key| hash[key].adopt!(self[key]) }
+  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|
+        YAML.load_file(rfile).push_keys(@config)
+      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,97 @@
+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'
+
+      # The name of the config field that list the verifier extention
+      # ruby scripts. This script contains a class which is used for verifying
+      # the variable with their associated context.
+      VERIFIER_EXTENSION_KEY = 'verifierExtention'
+
+      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]
+        @verifier_extensions = config[VERIFIER_EXTENSION_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|
+
+          report << SmellWarning.new(self, context,
+                    "has the variable name '#{name}'") if is_bad_name?(name)
+
+          accepted, message = verifier_extension_accepted?(context, name)
+          if !accepted
+            report << SmellWarning.new(self, context, message)
+          end
+        end
+      end
+
+      def verifier_extension_accepted?(p_context, p_name)
+        return true, nil if !@verifier_extensions
+        accepted, message = VerifierExtensionManager::accepted?(@verifier_extensions, p_context, p_name)
+        return accepted, message
+      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