kevinrutherford-reek 0.3.1.4

data/lib/reek/object_refs.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'sexp_processor'
+
+module Reek
+
+  class ObjectRefs  # :nodoc:
+    def initialize
+      @refs = Hash.new(0)
+      record_reference_to_self
+    end
+    
+    def record_reference_to_self
+      record_ref(SELF_REF)
+    end
+
+    def record_ref(exp)
+      type = exp[0]
+      case type
+      when :gvar
+        return
+      when :self
+        record_reference_to_self
+      else
+        @refs[exp] += 1
+      end
+    end
+
+    def refs_to_self
+      @refs[SELF_REF]
+    end
+
+    def max_refs
+      @refs.values.max or 0
+    end
+
+    # TODO
+    # Should be moved to Hash; but Hash has 58 methods, and there's currently
+    # no way to turn off that report; which would therefore make the tests fail
+    def max_keys
+      max = max_refs
+      @refs.reject {|key,val| val != max}.keys
+    end
+
+    def self_is_max?
+      max_keys.length == 0 || @refs[SELF_REF] == max_refs
+    end
+
+  private
+    
+    SELF_REF = Sexp.from_array([:lit, :self])
+
+  end
+end

data/lib/reek/options.rb

@@ -0,0 +1,92 @@
+require 'optparse'
+require 'reek/source'
+
+module Reek
+    
+  class Options
+
+    CTX_SORT = '%c %w (%s)'
+    SMELL_SORT = '[%s] %c %w'
+
+    def self.default_options
+      {
+        :format => CTX_SORT
+      }
+    end
+    
+    @@opts = default_options
+
+    def self.[](key)
+      @@opts[key]
+    end
+
+    def self.parse_args(args)
+      result = default_options
+      parser = OptionParser.new { |opts| set_options(opts, result) }
+      parser.parse!(args)
+      result
+    end
+    
+    def self.set_options(opts, config)
+      opts.banner = <<EOB
+Usage: #{opts.program_name} [options] files...
+
+If no files are given, Reek reads source code from standard input.
+See http://wiki.github.com/kevinrutherford/reek for detailed help.
+EOB
+      
+      opts.separator "\nOptions:"
+      set_help_option(opts)
+      set_sort_option(config, opts)
+      set_version_option(opts)
+    end
+
+    def self.parse(args)
+      begin
+        @@opts = parse_args(args)
+        if ARGV.length > 0
+          return Source.from_pathlist(ARGV)
+        else
+          return Source.from_io($stdin, 'stdin')
+        end
+      rescue OptionParser::ParseError, SystemCallError => err
+        fatal_error(err)
+      end
+    end
+
+  private
+    
+    def self.set_version_option(opts)
+      opts.on("-v", "--version", "Show version") do
+        puts "#{opts.program_name} #{Reek::VERSION}"
+        exit(0)
+      end
+    end
+
+    def self.set_help_option(opts)
+      opts.on("-h", "--help", "Show this message") do
+        puts opts
+        exit(0)
+      end
+    end
+
+    def self.set_sort_option(config, opts)
+      opts.on('-f', "--format FORMAT", 'Specify the format of smell warnings') do |arg|
+        config[:format] = arg unless arg.nil?
+      end
+      opts.on('-c', '--context-first', "Sort by context; sets the format string to \"#{CTX_SORT}\"") do
+        config[:format] = CTX_SORT
+      end
+      opts.on('-s', '--smell-first', "Sort by smell; sets the format string to \"#{SMELL_SORT}\"") do
+        config[:format] = SMELL_SORT
+      end
+    end
+    
+    def self.fatal_error(err) # :nodoc:
+      puts "Error: #{err}"
+      puts "Use '-h' for help."
+      exit(1)
+    end
+    
+  end
+end

data/lib/reek/rake_task.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+# Define a task library for running reek.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Reek
+
+  # A Rake task that runs reek on a set of source files.
+  #
+  # Example:
+  #
+  #   Reek::RakeTask.new do |t|
+  #     t.fail_on_error = false
+  #   end
+  #
+  # This will create a task that can be run with:
+  #
+  #   rake reek
+  #
+  # Examples:
+  #
+  #   rake reek                                # checks lib/**/*.rb
+  #   rake reek REEK_SRC=just_one_file.rb      # checks a single source file
+  #   rake reek REEK_OPTS=-s                   # sorts the report by smell
+  #
+  class RakeTask < ::Rake::TaskLib
+
+    # Name of reek task.
+    # Defaults to :reek.
+    attr_accessor :name
+
+    # Array of directories to be added to $LOAD_PATH before running reek.
+    # Defaults to ['<the absolute path to reek's lib directory>']
+    attr_accessor :libs
+
+    # Glob pattern to match source files.
+    # Setting the REEK_SRC environment variable overrides this.
+    # Defaults to 'lib/**/*.rb'.
+    attr_accessor :source_files
+
+    # String containing commandline options to be passed to Reek.
+    # Setting the REEK_OPTS environment variable overrides this value.
+    # Defaults to ''.
+    attr_accessor :reek_opts
+
+    # Array of commandline options to pass to ruby. Defaults to [].
+    attr_accessor :ruby_opts
+
+    # Whether or not to fail Rake when an error occurs (typically when smells are found).
+    # Defaults to true.
+    attr_accessor :fail_on_error
+
+    # Use verbose output. If this is set to true, the task will print
+    # the reek command to stdout. Defaults to false.
+    attr_accessor :verbose
+
+    # Defines a new task, using the name +name+.
+    def initialize(name = :reek)
+      @name = name
+      @libs = [File.expand_path(File.dirname(__FILE__) + '/../../lib')]
+      @source_files = nil
+      @ruby_opts = []
+      @reek_opts = ''
+      @fail_on_error = true
+      @sort = nil
+
+      yield self if block_given?
+      @source_files ||= 'lib/**/*.rb'
+      define
+    end
+
+private
+    
+    def define # :nodoc:
+      desc 'Check for code smells' unless ::Rake.application.last_comment
+      task(name) { run_task }
+      self
+    end
+    
+    def run_task
+      return if source_file_list.empty?
+      cmd = cmd_words.join(' ')
+      puts cmd if @verbose
+      raise('Smells found!') if !system(cmd) and fail_on_error
+    end
+
+    def self.reek_script
+      File.expand_path(File.dirname(__FILE__) + '/../../bin/reek')
+    end
+
+    def self.ruby_exe
+      File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+    end
+
+    def cmd_words
+      [RakeTask.ruby_exe] +
+          ruby_options +
+          [ %Q|"#{RakeTask.reek_script}"| ] +
+          [sort_option] +
+          source_file_list.collect { |fn| %["#{fn}"] }
+    end
+
+    def ruby_options
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      @ruby_opts.clone << "-I\"#{lib_path}\""
+    end
+    
+    def sort_option
+      ENV['REEK_OPTS'] || @reek_opts
+    end
+
+    def source_file_list # :nodoc:
+      files = ENV['REEK_SRC'] || @source_files
+      return [] unless files
+      return FileList[files]
+    end
+
+  end
+end

data/lib/reek/report.rb

@@ -0,0 +1,42 @@
+require 'set'
+require 'reek/smells/smell_detector'
+
+module Reek
+  class Report
+    include Enumerable
+
+    def initialize  # :nodoc:
+      @report = SortedSet.new
+    end
+
+    def each
+      @report.each { |smell| yield smell }
+    end
+
+    def <<(smell)  # :nodoc:
+      @report << smell
+      true
+    end
+    
+    def empty?  # :nodoc:
+      @report.empty?
+    end
+
+    def length  # :nodoc:
+      @report.length
+    end
+    
+    alias size length
+
+    def [](index)  # :nodoc:
+      @report.to_a[index]
+    end
+
+    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+    # this report.
+    def to_s
+      @report.map {|smell| smell.report}.join("\n")
+    end
+  end
+
+end

data/lib/reek/sexp_formatter.rb

@@ -0,0 +1,52 @@
+module Reek
+  class SexpFormatter
+    def self.format(sexp)
+      return sexp.to_s unless Array === sexp
+      first = sexp[1]
+      case sexp[0]
+      when :array
+        format_all(sexp, ', ')
+      when :call
+        meth, args = sexp[2..3]
+        result = format(first)
+        if meth.to_s == '[]'
+          result += (args.nil? ? '[]' : "[#{format(args)}]")
+        else
+          result += ".#{meth}" + (args ? "(#{format(args)})" : '')
+        end
+        result
+      when :colon2
+        format_all(sexp, '::')
+      when :const, :cvar, :dvar
+        format(first)
+      when :dot2
+        format_all(sexp, '..')
+      when :dstr
+        '"' + format_all(sexp, '') + '"'
+      when :evstr
+        "\#\{#{format(first)}\}"
+      when :fcall, :vcall
+        args = sexp[2]
+        result = first.to_s
+        result += "(#{format(args)})" if args
+        result
+      when :iter
+        'block'
+      when :lasgn
+        format_all(sexp, '=')
+      when :nth_ref
+        "$#{first}"
+      when :str
+        first
+      when :xstr
+        "`#{first}`"
+      else
+        sexp[-1].to_s
+      end
+    end
+    
+    def self.format_all(sexp, glue)
+      sexp[1..-1].map {|arg| format(arg)}.join(glue)
+    end
+  end
+end

data/lib/reek/singleton_method_context.rb

@@ -0,0 +1,27 @@
+require 'reek/name'
+require 'reek/method_context'
+require 'reek/sexp_formatter'
+
+module Reek
+  class SingletonMethodContext < MethodContext
+
+    def initialize(outer, exp)
+      super(outer, exp, false)
+      @name = Name.new(exp[2])
+      @receiver = SexpFormatter.format(exp[1])
+      record_depends_on_self
+    end
+
+    def envious_receivers
+      []
+    end
+    
+    def outer_name
+      "#{@outer.outer_name}#{@receiver}.#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@receiver}.#{@name}"
+    end
+  end
+end

data/lib/reek/smell_warning.rb

@@ -0,0 +1,49 @@
+require 'reek/options'
+
+module Reek
+
+  #
+  # Reports a warning that a smell has been found.
+  #
+  class SmellWarning
+    include Comparable
+
+    def initialize(smell, context, warning)
+      @smell = smell
+      @context = context
+      @warning = warning
+    end
+
+    def hash  # :nodoc:
+      report.hash
+    end
+
+    def <=>(other)
+      report <=> other.report
+    end
+
+    alias eql? <=>  # :nodoc:
+
+    #
+    # Returns +true+ only if this is a warning about an instance of
+    # +smell_class+ and its report string matches all of the +patterns+.
+    #
+    def matches?(smell_class, patterns)
+      return false unless smell_class.to_s == @smell.class.class_name
+      rpt = report
+      return patterns.all? {|exp| exp === rpt}
+    end
+
+    #
+    # Returns a copy of the current report format (see +Options+)
+    # in which the following magic tokens have been substituted:
+    #
+    # * %s <-- the name of the smell that was detected
+    # * %c <-- a description of the +CodeContext+ containing the smell
+    # * %w <-- the specific problem that was detected
+    #
+    def report
+      Options[:format].gsub(/\%s/, @smell.smell_name).gsub(/\%c/, @context.to_s).gsub(/\%w/, @warning)
+    end
+  end
+end

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,50 @@
+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. This includes public, protected and
+    # private methods, but 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'
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_METHODS_KEY => 25,
+          EXCLUDE_KEY => ['Array', 'Hash', 'Module', 'String']
+          )
+      end
+
+      def initialize(config = LargeClass.default_config)
+        super
+        @max_methods = config[MAX_ALLOWED_METHODS_KEY]
+      end
+
+      #
+      # Checks the length of the given +klass+.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(klass, report)
+        num_methods = klass.num_methods
+        return false if num_methods <= @max_methods
+        report << SmellWarning.new(self, klass,
+                    "has at least #{num_methods} methods")
+      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