reek 1.2.3 → 1.2.4

data/History.txt

@@ -1,4 +1,12 @@
-== 1.2.2 (under development in github)
+== 1.2.4 (2009-11-17)
+
+=== Major Changes
+* The -f, -c and -s options for formatting smell warnings have been removed
+
+=== Minor Changes
+* ControlCouple now warns about parameters defaulted to true/false
+
+== 1.2.3 (2009-11-2)
 
 === Minor Changes
 * New smell: Attribute (disabled by default)

data/features/options.feature

@@ -9,11 +9,6 @@ Feature: Reek can be controlled using command-line options
     Then the exit status indicates an error
     And it reports the error "Error: invalid option: --no-such-option"
 
-  Scenario: return non-zero status on missing argument
-    When I run reek -f
-    Then the exit status indicates an error
-    And it reports the error "Error: missing argument: -f"
-
   Scenario: display the current version number
     When I run reek --version
     Then it succeeds
@@ -41,9 +36,6 @@ Feature: Reek can be controlled using command-line options
 
       Report formatting:
           -a, --[no-]show-all              Show all smells, including those masked by config settings
-          -q, --quiet                      Suppress headings for smell-free source files
-          -f, --format FORMAT              Specify the format of smell warnings
-          -c, --context-first              Sort by context; sets the format string to "%m%c %w (%s)"
-          -s, --smell-first                Sort by smell; sets the format string to "%m[%s] %c %w"
+          -q, --[no-]quiet                 Suppress headings for smell-free source files
 
       """

data/features/samples.feature

@@ -4,6 +4,7 @@ Feature: Basic smell detection
   As a developer
   I want to detect the smels in my Ruby code
 
+  @inline
   Scenario: Correct smells from inline.rb
     When I run reek spec/samples/inline.rb
     Then the exit status indicates smells
@@ -57,7 +58,7 @@ Feature: Basic smell detection
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/optparse.rb -- 121 warnings:
+    spec/samples/optparse.rb -- 124 warnings:
       OptionParser has at least 42 methods (Large Class)
       OptionParser tests ((argv.size == 1) and Array.===(argv[0])) at least 3 times (Simulated Polymorphism)
       OptionParser tests a at least 7 times (Simulated Polymorphism)
@@ -70,6 +71,7 @@ Feature: Basic smell detection
       OptionParser#Completion::complete has approx 22 statements (Long Method)
       OptionParser#Completion::complete has the variable name 'k' (Uncommunicative Name)
       OptionParser#Completion::complete has the variable name 'v' (Uncommunicative Name)
+      OptionParser#Completion::complete is controlled by argument icase (Control Couple)
       OptionParser#Completion::complete refers to candidates more than self (Feature Envy)
       OptionParser#Completion::complete/block has the variable name 'k' (Uncommunicative Name)
       OptionParser#Completion::complete/block has the variable name 'v' (Uncommunicative Name)
@@ -78,6 +80,7 @@ Feature: Basic smell detection
       OptionParser#List#accept refers to pat more than self (Feature Envy)
       OptionParser#List#add_banner refers to opt more than self (Feature Envy)
       OptionParser#List#complete has 4 parameters (Long Parameter List)
+      OptionParser#List#complete is controlled by argument icase (Control Couple)
       OptionParser#List#reject has the variable name 't' (Uncommunicative Name)
       OptionParser#List#summarize refers to opt more than self (Feature Envy)
       OptionParser#List#update has 5 parameters (Long Parameter List)
@@ -127,6 +130,7 @@ Feature: Basic smell detection
       OptionParser#block/block is controlled by argument pkg (Control Couple)
       OptionParser#block/block is nested (Nested Iterators)
       OptionParser#complete has 4 parameters (Long Parameter List)
+      OptionParser#complete is controlled by argument icase (Control Couple)
       OptionParser#complete/block/block is nested (Nested Iterators)
       OptionParser#getopts calls result[opt] = false twice (Duplication)
       OptionParser#getopts has approx 17 statements (Long Method)
@@ -187,7 +191,7 @@ Feature: Basic smell detection
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/redcloth.rb -- 95 warnings:
+    spec/samples/redcloth.rb -- 96 warnings:
       RedCloth has at least 44 methods (Large Class)
       RedCloth takes parameters [atts, cite, content, tag] to 3 methods (Data Clump)
       RedCloth tests atts at least 6 times (Simulated Polymorphism)
@@ -217,6 +221,7 @@ Feature: Basic smell detection
       RedCloth#block_textile_table/block/block is nested (Nested Iterators)
       RedCloth#block_textile_table/block/block/block is nested (Nested Iterators)
       RedCloth#blocks has approx 18 statements (Long Method)
+      RedCloth#blocks is controlled by argument deep_code (Control Couple)
       RedCloth#blocks/block is controlled by argument deep_code (Control Couple)
       RedCloth#blocks/block/block is nested (Nested Iterators)
       RedCloth#check_refs is controlled by argument text (Control Couple)

data/features/step_definitions/reek_steps.rb

@@ -15,15 +15,15 @@ Then /^stdout equals "([^\"]*)"$/ do |report|
 end
 
 Then /^it succeeds$/ do
-  @last_exit_status.should == Reek::EXIT_STATUS[:success]
+  @last_exit_status.should == Reek::Application::STATUS_SUCCESS
 end
 
 Then /^the exit status indicates an error$/ do
-  @last_exit_status.should == Reek::EXIT_STATUS[:error]
+  @last_exit_status.should == Reek::Application::STATUS_ERROR
 end
 
 Then /^the exit status indicates smells$/ do
-  @last_exit_status.should == Reek::EXIT_STATUS[:smells]
+  @last_exit_status.should == Reek::Application::STATUS_SMELLS
 end
 
 Then /^it reports:$/ do |report|

data/lib/reek.rb

@@ -1,5 +1,5 @@
 $:.unshift File.dirname(__FILE__)
 
 module Reek # :doc:
-  VERSION = '1.2.3'
+  VERSION = '1.2.4'
 end

data/lib/reek/adapters/application.rb

@@ -4,48 +4,43 @@ require 'reek/adapters/core_extras'
 
 module Reek
 
-  EXIT_STATUS = {
-    :success => 0,
-    :error   => 1,
-    :smells  => 2
-  }
-
   #
   # Represents an instance of a Reek application.
   # This is the entry point for all invocations of Reek from the
   # command line.
   #
   class Application
-    def initialize(argv)
-      @options = Options.new(argv)
-    end
 
-    def examine_sources
-      # SMELL: Greedy Method
-      # Options.parse executes the -v and -h commands and throws a SystemExit
-      args = @options.parse
-      if args.length > 0
-        @sniffer = args.sniff
-      else
-        @sniffer = Reek::Sniffer.new($stdin.to_reek_source('$stdin'))
-      end
-    end
+    STATUS_SUCCESS = 0
+    STATUS_ERROR   = 1
+    STATUS_SMELLS  = 2
 
-    def reek
-      examine_sources
-      puts @options.create_report(@sniffer.sniffers).report
-      return EXIT_STATUS[@sniffer.smelly? ? :smells : :success]
+    def initialize(argv)
+      @options = Options.new(argv)
+      @status = STATUS_SUCCESS
     end
 
     def execute
       begin
-        return reek
-      rescue SystemExit => ex
-        return ex.status
+        cmd = @options.parse
+        cmd.execute(self)
       rescue Exception => error
         $stderr.puts "Error: #{error}"
-        return EXIT_STATUS[:error]
+        @status = STATUS_ERROR
       end
+      return @status
+    end
+
+    def output(text)
+      puts text
+    end
+
+    def report_success
+      @status = STATUS_SUCCESS
+    end
+
+    def report_smells
+      @status = STATUS_SMELLS
     end
   end
 end

data/lib/reek/adapters/command_line.rb

@@ -1,78 +1,77 @@
 require 'optparse'
 require 'reek'
 require 'reek/adapters/report'
+require 'reek/help_command'
+require 'reek/reek_command'
+require 'reek/version_command'
 
 module Reek
-    
-  # 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.
-  class Options
 
-    CTX_SORT = '%m%c %w (%s)'
-    SMELL_SORT = '%m[%s] %c %w'
+  class Options
 
     def initialize(argv)
       @argv = argv
       @parser = OptionParser.new
-      @quiet = false
+      @report_class = VerboseReport
       @show_all = false
-      @format = CTX_SORT
+      @command = nil
       set_options
     end
 
-    def parse
-      @parser.parse!(@argv)
-      @argv
-    end
-
-    def set_options
-      @parser.banner = <<EOB
-Usage: #{@parser.program_name} [options] [files]
+    def banner
+      progname = @parser.program_name
+      # SMELL:
+      # The following banner isn't really correct. Help, Version and Reek
+      # are really sub-commands (in the git/svn sense) and so the usage
+      # banner should show three different command-lines. The other
+      # options are all flags for the Reek sub-command.
+      #
+      # reek -h|--help           Display a help message
+      #
+      # reek -v|--version        Output the tool's version number
+      #
+      # reek [options] files     List the smells in the given files
+      #      -a|--[no-]show-all  Report masked smells
+      #      -q|-[no-]quiet      Only list files that have smells
+      #      files               Names of files or dirs to be checked
+      #
+      return <<EOB
+Usage: #{progname} [options] [files]
 
 Examples:
 
-#{@parser.program_name} lib/*.rb
-#{@parser.program_name} -q -a lib
-cat my_class.rb | #{@parser.program_name}
+#{progname} lib/*.rb
+#{progname} -q -a lib
+cat my_class.rb | #{progname}
 
 See http://wiki.github.com/kevinrutherford/reek for detailed help.
 
 EOB
+    end
 
-      @parser.separator "Common options:"
+    def parse
+      @parser.parse!(@argv)
+      @command ||= ReekCommand.new(@argv, @report_class, @show_all)
+    end
 
+    def set_options
+      @parser.banner = banner
+      @parser.separator "Common options:"
       @parser.on("-h", "--help", "Show this message") do
-        puts @parser
-        exit(EXIT_STATUS[:success])
+        @command = HelpCommand.new(@parser)
       end
       @parser.on("-v", "--version", "Show version") do
-        puts "#{@parser.program_name} #{Reek::VERSION}"
-        exit(EXIT_STATUS[:success])
+        @command = VersionCommand.new(@parser.program_name)
       end
 
       @parser.separator "\nReport formatting:"
-
       @parser.on("-a", "--[no-]show-all", "Show all smells, including those masked by config settings") do |opt|
         @show_all = opt
       end
-      @parser.on("-q", "--quiet", "Suppress headings for smell-free source files") do
-        @quiet = true
-      end
-      @parser.on('-f', "--format FORMAT", 'Specify the format of smell warnings') do |arg|
-        @format = arg unless arg.nil?
-      end
-      @parser.on('-c', '--context-first', "Sort by context; sets the format string to \"#{CTX_SORT}\"") do
-        @format = CTX_SORT
-      end
-      @parser.on('-s', '--smell-first', "Sort by smell; sets the format string to \"#{SMELL_SORT}\"") do
-        @format = SMELL_SORT
+      @parser.on("-q", "--[no-]quiet", "Suppress headings for smell-free source files") do |opt|
+        @report_class = opt ? QuietReport : VerboseReport
       end
     end
-
-    def create_report(sniffers)
-      @quiet ? QuietReport.new(sniffers, @format, @show_all) : FullReport.new(sniffers, @format, @show_all)
-    end
   end
+
 end

data/lib/reek/adapters/report.rb

@@ -1,34 +1,35 @@
 require 'set'
 require 'reek/adapters/command_line'   # SMELL: Global Variable
+require 'reek/masking_collection'
 
 module Reek
   class ReportSection
 
-    def initialize(sniffer, display_masked_warnings, format)  # :nodoc:
-      @format = format
-      @masked_warnings = SortedSet.new
-      @warnings = SortedSet.new
+    SMELL_FORMAT = '%m%c %w (%s)'
+
+    def initialize(sniffer, display_masked_warnings)
+      @cwarnings = MaskingCollection.new
       @desc = sniffer.desc
-      @display_masked_warnings = display_masked_warnings
+      @display_masked_warnings = display_masked_warnings  # SMELL: Control Couple
       sniffer.report_on(self)
     end
 
-    def <<(smell)  # :nodoc:
-      @warnings << smell
+    def found_smell(warning)
+      @cwarnings.add(warning)
       true
     end
 
-    def record_masked_smell(smell)
-      @masked_warnings << smell
+    def found_masked_smell(warning)
+      @cwarnings.add_masked(warning)
     end
 
     def num_masked_smells       # SMELL: getter
-      @masked_warnings.length
+      @cwarnings.num_masked_items
     end
 
     # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
     # this report, with a heading.
-    def full_report
+    def verbose_report
       result = header
       result += ":\n#{smell_list}" if should_report
       result += "\n"
@@ -37,56 +38,62 @@ module Reek
 
     def quiet_report
       return '' unless should_report
+      # SMELL: duplicate knowledge of the header layout
       "#{header}:\n#{smell_list}\n"
     end
 
     def header
-      @all_warnings = SortedSet.new(@warnings)      # SMELL: Temporary Field
-      @all_warnings.merge(@masked_warnings)
       "#{@desc} -- #{visible_header}#{masked_header}"
     end
 
     # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
     # this report.
     def smell_list
-      smells = @display_masked_warnings ? @all_warnings : @warnings
-      smells.map {|smell| "  #{smell.report(@format)}"}.join("\n")
+      result = []
+      if @display_masked_warnings
+        @cwarnings.each_item {|smell| result << "  #{smell.report(SMELL_FORMAT)}"}
+      else
+        @cwarnings.each_visible_item {|smell| result << "  #{smell.report(SMELL_FORMAT)}"}
+      end
+      result.join("\n")
     end
 
   private
 
     def should_report
-      @warnings.length > 0 or (@display_masked_warnings and @masked_warnings.length > 0)
+      @cwarnings.num_visible_items > 0 or (@display_masked_warnings and @cwarnings.num_masked_items > 0)
     end
 
     def visible_header
-      num_smells = @warnings.length
+      num_smells = @cwarnings.num_visible_items
       result = "#{num_smells} warning"
       result += 's' unless num_smells == 1
       result
     end
 
     def masked_header
-      num_masked_warnings = @all_warnings.length - @warnings.length
+      num_masked_warnings = @cwarnings.num_masked_items
       num_masked_warnings == 0 ? '' : " (+#{num_masked_warnings} masked)"
     end
   end
 
   class Report
-    def initialize(sniffers, format, display_masked_warnings = false)
-      @partials = Array(sniffers).map {|sn| ReportSection.new(sn, display_masked_warnings, format)}
+    def initialize(sniffers, display_masked_warnings = false)
+      @partials = Array(sniffers).map {|sn| ReportSection.new(sn, display_masked_warnings)}
     end
   end
 
-  class FullReport < Report
+  class VerboseReport < Report
+    # SMELL: Implementation Inheritance
     def report
-      @partials.map { |rpt| rpt.full_report }.join
+      @partials.map { |section| section.verbose_report }.join
     end
   end
 
   class QuietReport < Report
+    # SMELL: Implementation Inheritance
     def report
-      @partials.map { |rpt| rpt.quiet_report }.join
+      @partials.map { |section| section.quiet_report }.join
     end
   end
 end

data/lib/reek/adapters/spec.rb

@@ -44,7 +44,7 @@ module Reek
   module Spec
     module ReekMatcher
       def create_reporter(sniffers)
-        QuietReport.new(sniffers, '%c %w (%s)', false)
+        QuietReport.new(sniffers, false)
       end
       def report
         create_reporter(@sniffer.sniffers).report

data/lib/reek/code_context.rb

@@ -15,7 +15,7 @@ module Reek
   #
   class CodeContext
 
-    attr_reader :name
+    attr_reader :name, :exp
 
     def initialize(outer, exp)
       @outer = outer
@@ -23,7 +23,11 @@ module Reek
       @myself = nil
     end
 
-    def each(type, ignoring, &blk)
+    def local_nodes(type, &blk)
+      each_node(type, [:class, :module], &blk)
+    end
+
+    def each_node(type, ignoring, &blk)
       if block_given?
         @exp.look_for(type, ignoring, &blk)
       else