kevinrutherford-reek 1.1.3.9 → 1.1.3.10

data/History.txt

@@ -1,17 +1,18 @@
 == 1.2 (in progress -- see github)
 
 === Major Changes
-* Reek's RDoc is now hosted at http://rdoc.info/projects/kevinrutherford/reek
 * Reek's output reports are now formatted differently:
 ** Reek is no longer silent about smell-free source code
 ** Output now reports on all files examined, even if they have no smells
 ** Smell warnings are indented in the report; file summary headers are not
 ** Reports for multiple sources are run together; no more blank lines
+** Reports in spec matcher failures are quiet
 * The smells masked by *.reek config files can now be seen:
 ** The header for each source file now counts masked smells
 ** The --show-all (-a) option shows masked warnings in the report
 
 === Minor Changes
+* Reek's RDoc is now hosted at http://rdoc.info/projects/kevinrutherford/reek
 * Several changes to the LongMethod counting algorithm:
 ** LongMethod now counts statements deeper into each method (fixed #25)
 ** LongMethod no longer counts control structures, only their contained stmts

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008,2009 Kevin Rutherford
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/reek

@@ -6,15 +6,15 @@
 # Author: Kevin Rutherford
 #
 
-require 'reek'
-require 'reek/source'
 require 'reek/options'
 
 def reek(args)
   begin
-    source = Reek::Options.parse(args)
-    puts source.full_report
-    return source.smelly? ? 2 : 0
+    sniffer = Reek::Options.parse(args)
+    # SMELL:
+    # This should use the actual type of report selected by the user's options
+    puts sniffer.full_report
+    return sniffer.smelly? ? 2 : 0
   rescue SystemExit => ex
     return ex.status
   rescue Exception => error

data/features/options.feature

@@ -32,6 +32,7 @@ Feature: Reek can be controlled using command-line options
 
       Options:
           -a, --[no-]show-all              Show all smells, including those masked by config settings
+          -q, --quiet                      Suppress headings for smell-free source files
           -h, --help                       Show this message
           -f, --format FORMAT              Specify the format of smell warnings
           -c, --context-first              Sort by context; sets the format string to "%m%c %w (%s)"

data/features/reports.feature

@@ -37,4 +37,44 @@ Feature: Correctly formatted reports
 
       """
 
+  Scenario Outline: --quiet turns off headers for fragrant files
+    When I run reek <option> spec/samples/three_clean_files/*.rb
+    Then it succeeds
+    And it reports:
+      """
+
+
+      """
+
+    Examples:
+      | option  |
+      | -q      |
+      | --quiet |
+
+
+  Scenario Outline: -a turns on details in presence of -q
+    When I run reek <options> spec/samples/clean_due_to_masking/*.rb
+    Then it succeeds
+    And it reports:
+      """
+      spec/samples/clean_due_to_masking/dirty_one.rb -- 0 warnings (+6 masked):
+        (masked) Dirty has the variable name '@s' (Uncommunicative Name)
+        (masked) Dirty#a calls @s.title multiple times (Duplication)
+        (masked) Dirty#a calls puts(@s.title) multiple times (Duplication)
+        (masked) Dirty#a has the name 'a' (Uncommunicative Name)
+        (masked) Dirty#a/block has the variable name 'x' (Uncommunicative Name)
+        (masked) Dirty#a/block/block is nested (Nested Iterators)
+      spec/samples/clean_due_to_masking/dirty_two.rb -- 0 warnings (+6 masked):
+        (masked) Dirty has the variable name '@s' (Uncommunicative Name)
+        (masked) Dirty#a calls @s.title multiple times (Duplication)
+        (masked) Dirty#a calls puts(@s.title) multiple times (Duplication)
+        (masked) Dirty#a has the name 'a' (Uncommunicative Name)
+        (masked) Dirty#a/block has the variable name 'x' (Uncommunicative Name)
+        (masked) Dirty#a/block/block is nested (Nested Iterators)
+
+      """
 
+    Examples:
+      | options  |
+      | -q -a    |
+      | -a -q    |

data/features/stdin.feature

@@ -13,13 +13,22 @@ Feature: Reek reads from $stdin when no files are given
 
       """
 
-  Scenario: outputs nothing on empty stdin
+  Scenario: outputs header only on empty stdin
     When I pass "" to reek
     Then it succeeds
     And it reports:
       """
       $stdin -- 0 warnings
 
+      """
+
+  Scenario: outputs nothing on empty stdin in quiet mode
+    When I pass "" to reek --quiet
+    Then it succeeds
+    And it reports:
+      """
+
+
       """
 
   Scenario: return non-zero status when there are smells

data/features/step_definitions/reek_steps.rb

@@ -2,8 +2,8 @@ When /^I run reek (.*)$/ do |args|
   run args
 end
 
-When /^I pass "([^\"]*)" to reek$/ do |stdin|
-  run_with_pipe stdin
+When /^I pass "([^\"]*)" to reek *(.*)$/ do |stdin, args|
+  run_with_pipe(stdin, args)
 end
 
 When /^I run rake reek$/ do

data/features/support/env.rb

@@ -16,10 +16,10 @@ class CucumberWorld
     @last_stderr = IO.read(stderr_file.path)
   end
 
-  def run_with_pipe(stdin)
+  def run_with_pipe(stdin, args)
     stderr_file = Tempfile.new('cucumber')
     stderr_file.close
-    @last_stdout = `echo \"#{stdin}\" | ruby -Ilib bin/reek 2> #{stderr_file.path}`
+    @last_stdout = `echo \"#{stdin}\" | ruby -Ilib bin/reek #{args} 2> #{stderr_file.path}`
     @last_exit_status = $?.exitstatus
     @last_stderr = IO.read(stderr_file.path)
   end

data/lib/reek/class_context.rb

@@ -16,8 +16,8 @@ module Reek
     end
 
     def ClassContext.from_s(src)
-      source = Source.from_s(src)
-      CodeParser.new(Sniffer.new).process_class(source.generate_syntax_tree)
+      sniffer = src.sniff
+      CodeParser.new(sniffer).process_class(sniffer.source.syntax_tree)
     end
 
     def initialize(outer, name, superclass = nil)

data/lib/reek/code_parser.rb

@@ -9,6 +9,10 @@ require 'reek/method_context'
 require 'reek/singleton_method_context'
 require 'reek/yield_call_context'
 
+#
+# Extensions to +Sexp+ to allow +CodeParser+ to navigate the abstract
+# syntax tree more easily.
+#
 class Sexp
   def children
     find_all { |item| Sexp === item }

data/lib/reek/core_extras.rb

@@ -0,0 +1,50 @@
+require 'reek/source'         # SMELL: should refer to Sniffer
+require 'reek/sniffer'
+
+class File
+  #
+  # Creates a new +Sniffer+ that assumes this File contains Ruby source
+  # code and examines that code for smells.
+  #
+  def sniff
+    result = Reek::Sniffer.new
+    Reek::Source.from_path(self.path, result)
+    result
+  end
+end
+
+class IO
+  #
+  # Creates a new +Sniffer+ that assumes this IO stream contains Ruby source
+  # code and examines that code for smells.
+  #
+  def sniff(description = 'io')
+    code = self.readlines.join
+    result = Reek::Sniffer.new
+    Reek::Source.new(code, description, result)
+    result
+  end
+end
+
+class String
+  #
+  # Creates a new +Sniffer+ that assumes this String contains Ruby source
+  # code and examines that code for smells.
+  #
+  def sniff
+    result = Reek::Sniffer.new
+    Reek::Source.new(self, 'string', result)
+    result
+  end
+end
+
+class Array
+  #
+  # Creates a new +Sniffer+ that assumes this Array contains the names
+  # of Ruby source files and examines those files for smells.
+  #
+  def sniff
+    sniffers = self.map {|path| File.new(path).sniff }
+    Reek::SnifferSet.new(sniffers, 'dir')
+  end
+end

data/lib/reek/object_source.rb

@@ -1,15 +1,4 @@
 module Reek
-  class Source
-    #
-    # Factory method: creates a +Source+ from obj.
-    # The code is not parsed until +report+ is called.
-    # (This feature is only enabled if you have the ParseTree gem installed.)
-    #
-    def self.from_object(obj)
-      return ObjectSource.new(obj, obj.to_s)
-    end
-  end
-
   class ObjectSource < Source   # :nodoc:
 
     def self.unify(sexp)   # :nodoc:
@@ -20,7 +9,7 @@ module Reek
       return unifier.process(sexp[0])
     end
 
-    def initialize(code, desc)     # :nodoc:
+    def initialize(code, desc, sniffer)     # :nodoc:
       super
       @sniffer.disable(LargeClass)
     end
@@ -35,7 +24,7 @@ module Reek
       end
     end
 
-    def generate_syntax_tree
+    def syntax_tree
       if can_parse_objects?
         ObjectSource.unify(ParseTree.new.parse_tree(@source))
       else
@@ -47,12 +36,12 @@ end
 
 class Object
   #
-  # Constructs a Source representing this object; the source can then be used
-  # to generate an abstract syntax tree for the object, which can in turn then
-  # be examined for code smells.
+  # Constructs a Sniffer which examines this object for code smells.
   # (This feature is only enabled if you have the ParseTree gem installed.)
   #
-  def to_source
-    Reek::Source.from_object(self)
+  def sniff
+    result = Sniffer.new
+    ObjectSource.new(self, self.to_s, result)
+    result
   end
 end

data/lib/reek/options.rb

@@ -1,5 +1,7 @@
 require 'optparse'
+require 'reek'
 require 'reek/source'
+require 'reek/core_extras'       # SMELL
 
 module Reek
     
@@ -11,7 +13,8 @@ module Reek
     def self.default_options
       {
         :format => CTX_SORT,
-        :show_all => false
+        :show_all => false,
+        :quiet => false
       }
     end
     
@@ -40,12 +43,16 @@ EOB
       set_all_options(opts, config)
     end
 
+    # SMELL: Greedy Module
+    # This creates the command-line parser AND invokes it. And for the
+    # -v and -h options it also executes them. And it holds the config
+    # options for the rest of the application.
     def self.parse(args)
       @@opts = parse_args(args)
       if args.length > 0
-        return Source.from_pathlist(args)
+        return args.sniff
       else
-        return Source.from_io($stdin, '$stdin')
+        return $stdin.sniff('$stdin')
       end
     end
 
@@ -69,6 +76,9 @@ EOB
       opts.on("-a", "--[no-]show-all", "Show all smells, including those masked by config settings") do |opt|
         config[:show_all] = opt
       end
+      opts.on("-q", "--quiet", "Suppress headings for smell-free source files") do
+        config[:quiet] = true
+      end
     end
 
     def self.set_help_option(opts)

data/lib/reek/report.rb

@@ -1,22 +1,15 @@
 require 'set'
 require 'reek/sniffer'
-require 'reek/smells/smell_detector'
 
 module Reek
   class Report
     include Enumerable
 
-    def initialize(sniffer = nil)  # :nodoc:
+    def initialize(sniffer)  # :nodoc:
       @masked_warnings = SortedSet.new
       @warnings = SortedSet.new
-      sniffer.report_on(self) if sniffer
-    end
-
-    #
-    # Yields, in turn, each SmellWarning in this report.
-    #
-    def each
-      @warnings.each { |smell| yield smell }
+      @desc = sniffer.desc
+      sniffer.report_on(self)
     end
 
     #
@@ -52,19 +45,25 @@ module Reek
 
     # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
     # this report, with a heading.
-    def full_report(desc)
-      result = header(desc, @warnings.length)
-      result += ":\n#{to_s}" if should_report
+    def full_report
+      return quiet_report if Options[:quiet]
+      result = header(@warnings.length)
+      result += ":\n#{smell_list}" if should_report
       result += "\n"
       result
     end
 
+    def quiet_report
+      return '' unless should_report
+      "#{header(@warnings.length)}:\n#{smell_list}\n"
+    end
+
     def should_report
       @warnings.length > 0 or (Options[:show_all] and @masked_warnings.length > 0)
     end
 
-    def header(desc, num_smells)
-      result = "#{desc} -- #{num_smells} warning"
+    def header(num_smells)
+      result = "#{@desc} -- #{num_smells} warning"
       result += 's' unless num_smells == 1
       result += " (+#{@masked_warnings.length} masked)" unless @masked_warnings.empty?
       result
@@ -72,7 +71,7 @@ module Reek
 
     # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
     # this report.
-    def to_s
+    def smell_list
       all = SortedSet.new(@warnings)
       all.merge(@masked_warnings) if Options[:show_all]
       all.map {|smell| "  #{smell.report}"}.join("\n")
@@ -82,15 +81,8 @@ module Reek
   class ReportList
     include Enumerable
 
-    def initialize(sources)
-      @sources = sources
-    end
-
-    #
-    # Yields, in turn, each SmellWarning in every report in this report.
-    #
-    def each(&blk)
-      @sources.each {|src| src.report.each(&blk) }
+    def initialize(sniffers)
+      @sniffers = sniffers
     end
 
     def empty?
@@ -98,11 +90,18 @@ module Reek
     end
 
     def length
-      @sources.inject(0) {|sum, src| sum + src.report.length }
+      @sniffers.inject(0) {|sum, sniffer| sum + sniffer.num_smells }
     end
 
+    # SMELL: Shotgun Surgery
+    # This method and the next will have to be repeated for every new
+    # kind of report.
     def full_report
-      @sources.map { |src| src.full_report }.join
+      @sniffers.map { |sniffer| sniffer.full_report }.join
+    end
+
+    def quiet_report
+      @sniffers.map { |sniffer| sniffer.quiet_report }.join
     end
 
     #
@@ -110,7 +109,7 @@ module Reek
     # only if one of them has a report string matching all of the +patterns+.
     #
     def has_smell?(smell_class, patterns)
-      @sources.any? { |smell| smell.has_smell?(smell_class, patterns) }
+      @sniffers.any? { |sniffer| sniffer.has_smell?(smell_class, patterns) }
     end
   end
 end

data/lib/reek/sexp_formatter.rb

@@ -1,3 +1,5 @@
+require 'rubygems'
+require 'ruby_parser'
 require 'ruby2ruby'
 
 module Reek

data/lib/reek/smells/control_couple.rb

@@ -53,6 +53,11 @@ module Reek
       #
       def examine_context(cond)
         return unless cond.tests_a_parameter?
+        # SMELL: Duplication
+        # This smell is reported once for each conditional that tests the
+        # same parameter. Which means that the same smell can recur within
+        # a single sniffer. Which in turn means that the sniffer can't count
+        # its smells without knowing which are duplicates.
         found(cond, "is controlled by argument #{SexpFormatter.format(cond.if_expr)}")
       end
     end

data/lib/reek/sniffer.rb

@@ -10,6 +10,8 @@ require 'reek/smells/nested_iterators'
 require 'reek/smells/uncommunicative_name'
 require 'reek/smells/utility_function'
 require 'reek/config_file'
+require 'reek/code_parser'
+require 'reek/report'
 require 'yaml'
 
 class Hash
@@ -41,6 +43,8 @@ end
 module Reek
   class Sniffer
 
+    # SMELL: Duplication
+    # This list should be calculated by looking in the source folder.
     SMELL_CLASSES = [
       Smells::ControlCouple,
       Smells::Duplication,
@@ -54,13 +58,12 @@ module Reek
       Smells::UtilityFunction,
     ]
 
+    attr_accessor :source
+
     def initialize
-      defaults_file = File.join(File.dirname(__FILE__), '..', '..', 'config', 'defaults.reek')
-      @config = YAML.load_file(defaults_file)
       @typed_detectors = nil
       @detectors = Hash.new
       SMELL_CLASSES.each { |klass| @detectors[klass] = DetectorStack.new(klass.new) }
-      @listeners = []
     end
 
     #
@@ -93,6 +96,60 @@ module Reek
       listeners.each {|smell| smell.examine(scope) } if listeners
     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
+        CodeParser.new(self).process(@source.syntax_tree)
+        @report = Report.new(self)
+      end
+      @report
+    end
+
+    def smelly?
+      report.length > 0
+    end
+
+    def quiet_report
+      report.quiet_report
+    end
+
+    # SMELL: Shotgun Surgery
+    # This and the above method will need to be replicated for every new
+    # kind of report.
+    def full_report
+      report.full_report
+    end
+
+    def num_smells
+      report.length
+    end
+
+    def desc
+      # SMELL: Special Case
+      # Only used in the Report tests, because they don't always create a Source.
+      @source ? @source.desc : "unknown"
+    end
+
+    #
+    # Checks 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.has_smell?(smell_class, patterns)
+    end
+
+    def smells_only_of?(klass, patterns)
+      report.length == 1 and has_smell?(klass, patterns)
+    end
+
+    def sniff
+      self
+    end
+
 private
 
     def smell_listeners()
@@ -110,4 +167,42 @@ private
       all_reekfiles(parent) + Dir["#{path}/*.reek"]
     end
   end
+
+  class SnifferSet
+
+    attr_reader :sniffers, :desc
+
+    def initialize(sniffers, desc)
+      @sniffers = sniffers
+      @desc = desc
+    end
+
+    def smelly?
+      @sniffers.any? {|sniffer| sniffer.smelly? }
+    end
+
+    #
+    # Checks 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=[])
+      @sniffers.any? {|sniffer| sniffer.has_smell?(smell_class, patterns)}
+    end
+
+    def smells_only_of?(klass, patterns)
+      ReportList.new(@sniffers).length == 1 and has_smell?(klass, patterns)
+    end
+
+    def quiet_report
+      ReportList.new(@sniffers).quiet_report
+    end
+
+
+    # SMELL: Shotgun Surgery
+    # This and the above method will need to be replicated for every new
+    # kind of report.
+    def full_report
+      ReportList.new(@sniffers).full_report
+    end
+  end
 end