reek 1.2.6 → 1.2.8

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -0,0 +1,74 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), '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 +UncommunicativeMethodName+ checks for
+    # * 1-character names
+    # * names ending with a number
+    #
+    class UncommunicativeMethodName < SmellDetector
+
+      SMELL_CLASS = 'UncommunicativeName'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      METHOD_NAME_KEY = 'method_name'
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be reported.
+      REJECT_KEY = 'reject'
+
+      DEFAULT_REJECT_SET = [/^[a-z]$/, /[0-9]$/, /[A-Z]/]
+      
+      # 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'
+
+      DEFAULT_ACCEPT_SET = []
+
+      def self.default_config
+        super.adopt(
+          REJECT_KEY => DEFAULT_REJECT_SET,
+          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:defn, :defs]
+      end
+
+      def initialize(source, config = UncommunicativeMethodName.default_config)
+        super(source, config)
+      end
+
+      #
+      # Checks the given +context+ for uncommunicative names.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
+        @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
+        name = ctx.name
+        return [] if @accept_names.include?(ctx.full_name)
+        var = name.to_s.gsub(/^[@\*\&]*/, '')
+        return [] if @accept_names.include?(var)
+        return [] unless @reject_names.detect {|patt| patt === var}
+        smell = SmellWarning.new('UncommunicativeName', ctx.full_name, [ctx.exp.line],
+          "has the name '#{name}'",
+          @source, 'UncommunicativeMethodName', {METHOD_NAME_KEY => name.to_s})
+        [smell]
+      end
+    end
+  end
+end

data/lib/reek/smells/uncommunicative_module_name.rb

@@ -0,0 +1,74 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), '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 +UncommunicativeModuleName+ checks for
+    # * 1-character names
+    # * names ending with a number
+    #
+    class UncommunicativeModuleName < SmellDetector
+
+      SMELL_CLASS = 'UncommunicativeName'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      MODULE_NAME_KEY = 'module_name'
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be reported.
+      REJECT_KEY = 'reject'
+
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
+      
+      # 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'
+
+      DEFAULT_ACCEPT_SET = ['Inline::C']
+
+      def self.default_config
+        super.adopt(
+          REJECT_KEY => DEFAULT_REJECT_SET,
+          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:module, :class]
+      end
+
+      def initialize(source, config = UncommunicativeModuleName.default_config)
+        super(source, config)
+      end
+
+      #
+      # Checks the given +context+ for uncommunicative names.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
+        @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
+        name = ctx.exp.simple_name
+        return [] if @accept_names.include?(ctx.full_name)
+        var = name.to_s.gsub(/^[@\*\&]*/, '')
+        return [] if @accept_names.include?(var)
+        return [] unless @reject_names.detect {|patt| patt === var}
+        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+          "has the name '#{name}'",
+          @source, SMELL_SUBCLASS, {MODULE_NAME_KEY => name.to_s})
+        [smell]
+      end
+    end
+  end
+end

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -0,0 +1,79 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), '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 +UncommunicativeParameterName+ checks for
+    # * 1-character names
+    # * names ending with a number
+    #
+    class UncommunicativeParameterName < SmellDetector
+
+      SMELL_CLASS = 'UncommunicativeName'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      PARAMETER_NAME_KEY = 'parameter_name'
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be reported.
+      REJECT_KEY = 'reject'
+
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/, /[A-Z]/]
+
+      # 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'
+
+      DEFAULT_ACCEPT_SET = []
+
+      def self.default_config
+        super.adopt(
+                REJECT_KEY => DEFAULT_REJECT_SET,
+                ACCEPT_KEY => DEFAULT_ACCEPT_SET
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:defn, :defs]
+      end
+
+      def initialize(source, config = UncommunicativeParameterName.default_config)
+        super(source, config)
+      end
+
+      #
+      # Checks the given +context+ for uncommunicative names.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
+        @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
+        ctx.exp.parameter_names.select do |name|
+          is_bad_name?(name, ctx)
+        end.map do |name|
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+                                   "has the parameter name '#{name}'",
+                                   @source, SMELL_SUBCLASS, {PARAMETER_NAME_KEY => name.to_s})
+          smell
+        end
+      end
+
+      def is_bad_name?(name, ctx)
+        var = name.to_s.gsub(/^[@\*\&]*/, '')
+        return false if var == '*' or @accept_names.include?(var)
+        @reject_names.detect {|patt| patt === var}
+      end
+    end
+  end
+end

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -0,0 +1,89 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), '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 ending with a number
+    #
+    class UncommunicativeVariableName < SmellDetector
+
+      SMELL_CLASS = 'UncommunicativeName'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      VARIABLE_NAME_KEY = 'variable_name'
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be reported.
+      REJECT_KEY = 'reject'
+
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/, /[A-Z]/]
+
+      # 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'
+
+      DEFAULT_ACCEPT_SET = []
+
+      def self.default_config
+        super.adopt(
+                REJECT_KEY => DEFAULT_REJECT_SET,
+                ACCEPT_KEY => DEFAULT_ACCEPT_SET
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:module, :class, :defn, :defs]
+      end
+
+      def initialize(source, config = UncommunicativeVariableName.default_config)
+        super(source, config)
+      end
+
+      #
+      # Checks the given +context+ for uncommunicative names.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
+        @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
+        variable_names(ctx.exp).select do |name, lines|
+          is_bad_name?(name, ctx)
+        end.map do |name, lines|
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
+                           "has the variable name '#{name}'",
+                           @source, SMELL_SUBCLASS, {VARIABLE_NAME_KEY => name.to_s})
+        end
+      end
+
+      def is_bad_name?(name, ctx)
+        var = name.to_s.gsub(/^[@\*\&]*/, '')
+        return false if @accept_names.include?(var)
+        @reject_names.detect {|patt| patt === var}
+      end
+
+      def variable_names(exp)
+        assignment_nodes = exp.each_node(:lasgn, [:class, :module, :defs, :defn])
+        case exp.first
+          when :class, :module
+            assignment_nodes += exp.each_node(:iasgn, [:class, :module])
+        end
+        result = Hash.new {|hash, key| hash[key] = []}
+        assignment_nodes.each {|asgn| result[asgn[1]].push(asgn.line) }
+        result
+      end
+    end
+  end
+end

data/lib/reek/smells/utility_function.rb

@@ -1,5 +1,6 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source', 'reference_collector')
 
 module Reek
   module Smells
@@ -16,8 +17,27 @@ module Reek
     # * doesn't use any of self's instance variables, and
     # * doesn't use any of self's methods
     #
+    # A Utility Function often arises because it must manipulate
+    # other objects (usually its arguments) to get them into a
+    # useful form; one force preventing them (the
+    # arguments) doing this themselves is that the common
+    # knowledge lives outside the arguments, or the arguments
+    # are of too basic a type to justify extending that type.
+    # Therefore there must be something which 'knows' about the contents
+    # or purposes of the arguments.  That thing would have to
+    # be more than just a basic type, because the basic types
+    # are either containers which don't know about their
+    # contents, or they are single objects which can't capture
+    # their relationship with their fellows of the same type.
+    # So, this thing with the extra knowledge should be
+    # reified into a class, and the utility method will most
+    # likely belong there.
+    #
     class UtilityFunction < SmellDetector
 
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = 'LowCohesion'
+
       # The name of the config field that sets the maximum number of
       # calls permitted within a helper method. Any method with more than
       # this number of method calls on other objects will be considered a
@@ -26,24 +46,43 @@ module Reek
 
       DEFAULT_HELPER_CALLS_LIMIT = 1
 
-      def self.default_config
-        super.adopt(HELPER_CALLS_LIMIT_KEY => DEFAULT_HELPER_CALLS_LIMIT)
+      class << self
+        def contexts      # :nodoc:
+          [:defn]
+        end
+        def default_config
+          super.adopt(HELPER_CALLS_LIMIT_KEY => DEFAULT_HELPER_CALLS_LIMIT)
+        end
       end
 
-      def initialize(config = UtilityFunction.default_config)
-        super(config)
+      def initialize(source, config = UtilityFunction.default_config)
+        super(source, config)
       end
 
       #
       # Checks whether the given +method+ is a utility function.
-      # Remembers any smells found.
       #
-      def examine_context(method)
-        return false if method.num_statements == 0 or
-          method.depends_on_instance? or
-          method.calls.keys.length <= value(HELPER_CALLS_LIMIT_KEY, method, DEFAULT_HELPER_CALLS_LIMIT)
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(method_ctx)
+        return [] if method_ctx.num_statements == 0
+        return [] if depends_on_instance?(method_ctx.exp)
+        return [] if num_helper_methods(method_ctx) <= value(HELPER_CALLS_LIMIT_KEY, method_ctx, DEFAULT_HELPER_CALLS_LIMIT)
           # SMELL: loads of calls to value{} with the above pattern
-        found(method, "doesn't depend on instance state")
+        smell = SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
+          "doesn't depend on instance state",
+          @source, SMELL_SUBCLASS)
+        [smell]
+      end
+
+    private
+
+      def depends_on_instance?(exp)
+        Reek::Source::ReferenceCollector.new(exp).num_refs_to_self > 0
+      end
+
+      def num_helper_methods(method_ctx)
+        method_ctx.local_nodes(:call).length
       end
     end
   end

data/lib/reek/smells.rb

@@ -0,0 +1,29 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'attribute')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'boolean_parameter')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'class_variable')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'control_couple')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'data_clump')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'duplication')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'feature_envy')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'irresponsible_module')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'large_class')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'long_method')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'long_parameter_list')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'long_yield_list')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'nested_iterators')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'simulated_polymorphism')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_method_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_module_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_parameter_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_variable_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'utility_function')
+# SMELL: Duplication -- all these should be found automagically
+
+module Reek
+
+  #
+  # This module contains the various smell detectors.
+  #
+  module Smells
+  end
+end

data/lib/reek/source/code_comment.rb

@@ -0,0 +1,37 @@
+
+module Reek
+  module Source
+
+    #
+    # A comment header from an abstract syntax tree; found directly above
+    # module, class and method definitions.
+    #
+    class CodeComment
+      CONFIG_REGEX = /:reek:(\w+)(:\s*\{.*?\})?/
+
+      def initialize(text)
+        @config =  Hash.new { |hash,key| hash[key] = {} }
+        @text = text.gsub(CONFIG_REGEX) do |m|
+          add_to_config($1, $2)
+          ''
+        end.gsub(/#/, '').gsub(/\n/, '').strip
+      end
+
+      def config
+        @config
+      end
+
+      def is_descriptive?
+        @text.split(/\s+/).length >= 2
+      end
+
+    protected
+      def add_to_config(smell, options)
+        options ||= ': { enabled: false }'
+        @config.merge! YAML.load(smell.gsub(/(?:^|_)(.)/) { $1.upcase } + options)
+        # extend this to all configs --------------------------^
+        # extend to allow configuration of whole smell class, not just subclass
+      end
+    end
+  end
+end

data/lib/reek/source/config_file.rb

@@ -0,0 +1,72 @@
+require 'yaml'
+
+module Reek
+  module Source
+
+    #
+    # A file called <something>.reek containing configuration settings for
+    # any or all of the smell detectors.
+    #
+    class ConfigFile
+      @@bad_config_files = []
+
+      #
+      # Load the YAML config file from the supplied +file_path+.
+      #
+      def initialize(file_path)
+        @file_path = file_path
+        @hash = load
+      end
+
+      #
+      # Configure the given sniffer using the contents of the config file.
+      #
+      def configure(sniffer)
+        @hash.each do |klass_name, config|
+          klass = find_class(klass_name)
+          sniffer.configure(klass, config) if klass
+        end
+      end
+
+      #
+      # Find the class with this name if it exsits.
+      # If not, report the problem and return +nil+.
+      #
+      def find_class(name)
+        begin
+          klass = Reek::Smells.const_get(name)
+        rescue
+          klass = nil
+        end
+        problem("\"#{name}\" is not a code smell") unless klass
+        klass
+      end
+
+      #
+      # Load the file path with which this was initialized,
+      # unless it is already known to be a bad configuration file.
+      # If it won't load, then it is considered a bad file.
+      #
+      def load
+        unless @@bad_config_files.include?(@file_path)
+          begin
+            return YAML.load_file(@file_path) || {}
+          rescue Exception => err
+            @@bad_config_files << @file_path
+            problem(err.to_s)
+          end
+        end
+        return {}
+      end
+
+      #
+      # Report invalid configuration file to standard
+      # Error.
+      #
+      def problem(reason)
+        $stderr.puts "Error: Invalid configuration file \"#{File.basename(@file_path)}\" -- #{reason}"
+        # SMELL: Duplication of 'Error:'
+      end
+    end
+  end
+end

data/lib/reek/source/core_extras.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'source_code')
+
+#
+# Extensions to +File+ needed by Reek.
+#
+class File
+  #
+  # Creates a new +Source+ that assumes this File contains Ruby source
+  # code and prepares it to be examined for code smells.
+  #
+  # @return [Reek::Source::SourceFile]
+  #
+  def to_reek_source
+    Reek::Source::SourceFile.new(path)
+  end
+end
+
+#
+# Extensions to +IO+ needed by Reek.
+#
+class IO
+  #
+  # Creates a new +Source+ that assumes this IO stream contains Ruby source
+  # code and prepares it to be examined for code smells.
+  #
+  # @return [Reek::Source::SourceCode]
+  #
+  def to_reek_source(description = 'io')
+    Reek::Source::SourceCode.new(self.readlines.join, description)
+  end
+end
+
+#
+# Extensions to +String+ needed by Reek.
+#
+class String
+  #
+  # Creates a new +Source+ that assumes this string contains Ruby source
+  # code and prepares it to be examined for code smells.
+  #
+  # @return [Reek::Source::SourceCode]
+  #
+  def to_reek_source
+    Reek::Source::SourceCode.new(self, 'string')
+  end
+end

data/lib/reek/source/reference_collector.rb

@@ -0,0 +1,28 @@
+
+module Reek
+  module Source
+
+    #
+    # Locates references to the current object within a portion
+    # of an abstract syntax tree.
+    #
+    class ReferenceCollector
+      STOP_NODES = [:class, :module, :defn, :defs]
+
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def num_refs_to_self
+        result = 0
+        [:self, :zsuper, :ivar, :iasgn].each do |node_type|
+          @ast.look_for(node_type, STOP_NODES) { result += 1}
+        end
+        @ast.look_for(:call, STOP_NODES) do |call|
+          result += 1 unless call.receiver
+        end
+        result
+      end
+    end
+  end
+end

data/lib/reek/source/sexp_formatter.rb

@@ -0,0 +1,17 @@
+require 'ruby2ruby'
+
+module Reek
+  module Source
+
+    #
+    # Formats snippets of syntax tree back into Ruby source code.
+    #
+    class SexpFormatter
+      def self.format(sexp)
+        return sexp.to_s unless Array === sexp
+        sexp = YAML::load(YAML::dump(sexp))
+        Ruby2Ruby.new.process(sexp)
+      end
+    end
+  end
+end

data/lib/reek/source/source_code.rb

@@ -0,0 +1,44 @@
+require 'ruby_parser'
+require File.join(File.dirname(File.expand_path(__FILE__)), 'config_file')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'tree_dresser')
+
+module Reek
+  module Source
+
+    #
+    # A +Source+ object represents a chunk of Ruby source code.
+    #
+    class SourceCode
+
+      @@err_io = $stderr
+
+      class << self
+        def err_io=(io)
+          original = @@err_io
+          @@err_io = io
+          original
+        end
+      end
+
+      attr_reader :desc
+
+      def initialize(code, desc, parser = RubyParser.new)
+        @source = code
+        @desc = desc
+        @parser = parser
+      end
+
+      def configure(sniffer) end
+
+      def syntax_tree
+        begin
+          ast = @parser.parse(@source, @desc)
+        rescue Exception => error
+          @@err_io.puts "#{desc}: #{error.class.name}: #{error}"
+        end
+        ast ||= s()
+        TreeDresser.new.dress(ast)
+      end
+    end
+  end
+end