kevinrutherford-reek 1.1.3.10 → 1.1.3.11

data/lib/reek/adapters/report.rb

@@ -0,0 +1,91 @@
+require 'set'
+require 'reek/command_line'   # SMELL: Global Variable
+
+module Reek
+  class ReportSection
+
+    def initialize(sniffer)  # :nodoc:
+      @masked_warnings = SortedSet.new
+      @warnings = SortedSet.new
+      @desc = sniffer.desc
+      sniffer.report_on(self)
+    end
+
+    def <<(smell)  # :nodoc:
+      @warnings << smell
+      true
+    end
+
+    def record_masked_smell(smell)
+      @masked_warnings << smell
+    end
+
+    def num_masked_smells       # SMELL: getter
+      @masked_warnings.length
+    end
+
+    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+    # this report, with a heading.
+    def full_report
+      return quiet_report if Options[:quiet]
+      result = header
+      result += ":\n#{smell_list}" if should_report
+      result += "\n"
+      result
+    end
+
+    def quiet_report
+      return '' unless should_report
+      "#{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 = Options[:show_all] ? @all_warnings : @warnings
+      smells.map {|smell| "  #{smell.report}"}.join("\n")
+    end
+
+  private
+
+    def should_report
+      @warnings.length > 0 or (Options[:show_all] and @masked_warnings.length > 0)
+    end
+
+    def visible_header
+      num_smells = @warnings.length
+      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 == 0 ? '' : " (+#{num_masked_warnings} masked)"
+    end
+  end
+
+  class Report
+
+    def initialize(sniffers)
+      @partials = Array(sniffers).map {|sn| ReportSection.new(sn)}
+    end
+
+    # SMELL: Shotgun Surgery
+    # This method and the next will have to be repeated for every new
+    # kind of report.
+    def full_report
+      @partials.map { |rpt| rpt.full_report }.join
+    end
+
+    def quiet_report
+      @partials.map { |rpt| rpt.quiet_report }.join
+    end
+  end
+end

data/lib/reek/adapters/source.rb

@@ -0,0 +1,49 @@
+require 'reek/adapters/config_file'
+
+module Reek
+
+  #
+  # A +Source+ object represents a chunk of Ruby source code.
+  #
+  class Source
+
+    attr_reader :desc
+
+    def initialize(code, desc)
+      @source = code
+      @desc = desc
+    end
+
+    def configure(sniffer) end
+
+    def syntax_tree
+      RubyParser.new.parse(@source, @desc) || s()
+    end
+  end
+
+  #
+  # Represents a file of Ruby source, whose contents will be examined
+  # for code smells.
+  #
+  class SourceFile < Source
+
+    def initialize(file)
+      @file = file
+      super(@file.lines.to_a.join, @file.path)
+    end
+
+    def configure(sniffer)
+      path = File.expand_path(File.dirname(@file.path))
+      all_config_files(path).each { |cf| ConfigFile.new(cf).configure(sniffer) }
+    end
+
+  private
+
+    def all_config_files(path)
+      return [] unless File.exist?(path)
+      parent = File.dirname(path)
+      return [] if path == parent
+      all_config_files(parent) + Dir["#{path}/*.reek"]
+    end
+  end
+end

data/lib/reek/{spec.rb → adapters/spec.rb}

@@ -1,4 +1,7 @@
 require 'reek/sniffer'
+require 'reek/adapters/core_extras'
+require 'reek/adapters/object_source'
+require 'reek/adapters/report'
 
 module Reek
 
@@ -40,20 +43,30 @@ module Reek
   #   ruby.should_not reek_of(:FeatureEnvy)
   #
   module Spec
+    module ReekMatcher
+      def report
+        Report.new(@sniffer.sniffers).quiet_report
+      end
+    end
+
     class ShouldReek        # :nodoc:
+      include ReekMatcher
+
       def matches?(actual)
         @sniffer = actual.sniff
         @sniffer.smelly?
       end
       def failure_message_for_should
-        "Expected source to reek, but it didn't"
+        "Expected #{@sniffer.desc} to reek, but it didn't"
       end
       def failure_message_for_should_not
-        "Expected no smells, but got:\n#{@sniffer.quiet_report}"
+        "Expected no smells, but got:\n#{report}"
       end
     end
 
     class ShouldReekOf        # :nodoc:
+      include ReekMatcher
+
       def initialize(klass, patterns)
         @klass = klass
         @patterns = patterns
@@ -66,21 +79,19 @@ module Reek
         "Expected #{@sniffer.desc} to reek of #{@klass}, but it didn't"
       end
       def failure_message_for_should_not
-        "Expected #{@sniffer.desc} not to reek of #{@klass}, but got:\n#{@sniffer.quiet_report}"
+        "Expected #{@sniffer.desc} not to reek of #{@klass}, but got:\n#{report}"
       end
     end
 
-    class ShouldReekOnlyOf        # :nodoc:
-      def initialize(klass, patterns)
-        @klass = klass
-        @patterns = patterns
-      end
+    class ShouldReekOnlyOf < ShouldReekOf        # :nodoc:
+      include ReekMatcher
+
       def matches?(actual)
         @sniffer = actual.sniff
         @sniffer.smells_only_of?(@klass, @patterns)
       end
       def failure_message_for_should
-        "Expected #{@sniffer.desc} to reek only of #{@klass}, but got:\n#{@sniffer.quiet_report}"
+        "Expected #{@sniffer.desc} to reek only of #{@klass}, but got:\n#{report}"
       end
       def failure_message_for_should_not
         "Expected #{@sniffer.desc} not to reek only of #{@klass}, but it did"

data/lib/reek/block_context.rb

@@ -11,7 +11,7 @@ module Reek
       case slice(0)
       when :masgn
         @names = arg[1..-1].map {|lasgn| Name.new(lasgn[1]) }
-      when :lasgn
+      when :lasgn, :iasgn
         @names = [Name.new(arg)]
       end
     end

data/lib/reek/class_context.rb

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

data/lib/reek/code_parser.rb

@@ -82,6 +82,10 @@ module Reek
       @element.record_depends_on_self if /^@/ === exp[1].to_s
     end
 
+    def process_zsuper(exp)
+      @element.record_use_of_self
+    end
+
     def process_lit(exp)
       val = exp[1]
       @element.record_depends_on_self if val == :self

data/lib/reek/command_line.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+require 'reek'
+
+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'
+
+    def self.default_options
+      {
+        :format => CTX_SORT,
+        :show_all => false,
+        :quiet => false
+      }
+    end
+
+    # SMELL: Global Variable
+    @@opts = default_options
+
+    def self.[](key)
+      @@opts[key]
+    end
+
+    def initialize(argv)
+      @argv = argv
+      @parser = OptionParser.new
+      set_options
+    end
+
+    def parse
+      @parser.parse!(@argv)
+      @argv
+    end
+
+    def set_options
+      @parser.banner = <<EOB
+Usage: #{@parser.program_name} [options] [files]
+
+Examples:
+
+#{@parser.program_name} lib/*.rb
+#{@parser.program_name} -q -a lib
+cat my_class.rb | #{@parser.program_name}
+
+See http://wiki.github.com/kevinrutherford/reek for detailed help.
+
+EOB
+
+      @parser.separator "Common options:"
+
+      @parser.on("-h", "--help", "Show this message") do
+        puts @parser
+        exit(0)
+      end
+      @parser.on("-v", "--version", "Show version") do
+        puts "#{@parser.program_name} #{Reek::VERSION}"
+        exit(0)
+      end
+
+      @parser.separator "\nReport formatting:"
+
+      @parser.on("-a", "--[no-]show-all", "Show all smells, including those masked by config settings") do |opt|
+        @@opts[:show_all] = opt
+      end
+      @parser.on("-q", "--quiet", "Suppress headings for smell-free source files") do
+        @@opts[:quiet] = true
+      end
+      @parser.on('-f', "--format FORMAT", 'Specify the format of smell warnings') do |arg|
+        @@opts[:format] = arg unless arg.nil?
+      end
+      @parser.on('-c', '--context-first', "Sort by context; sets the format string to \"#{CTX_SORT}\"") do
+        @@opts[:format] = CTX_SORT
+      end
+      @parser.on('-s', '--smell-first', "Sort by smell; sets the format string to \"#{SMELL_SORT}\"") do
+        @@opts[:format] = SMELL_SORT
+      end
+    end
+  end
+end

data/lib/reek/detector_stack.rb

@@ -7,18 +7,35 @@ module Reek
     end
 
     def push(config)
-      det = @detectors[0].copy
-      det.configure_with(config)
-      @detectors.each {|smell| smell.be_masked}
-      @detectors << det
+      clone = @detectors[0].copy
+      clone.configure_with(config)
+      @detectors.each {|det| det.be_masked}
+      @detectors << clone
     end
 
     def listen_to(hooks)
-      @detectors.each { |smell| smell.listen_to(hooks) }
+      @detectors.each { |det| det.listen_to(hooks) }
     end
 
     def report_on(report)
-      @detectors.each { |smell| smell.report_on(report) }
+      @detectors.each { |det| det.report_on(report) }
+    end
+
+    def num_smells
+      total = 0
+      @detectors.each { |det| total += det.num_smells }
+      total
+    end
+
+    def has_smell?(patterns)
+      @detectors.each { |det| return true if det.has_smell?(patterns) }
+      false
+    end
+
+    def smelly?
+      # SMELL: Duplication: look at al those loops!
+      @detectors.each { |det| return true if det.smelly? }
+      false
     end
   end
 end

data/lib/reek/exceptions.reek

@@ -1,4 +1,7 @@
---- 
+---
+Duplication:
+  exclude:
+  - Reek::Options#set_options
 FeatureEnvy:
   exclude:
   - examine_context
@@ -8,6 +11,7 @@ LargeClass:
 LongMethod:
   exclude:
   - Reek::SexpFormatter#self.format
+  - Reek::Options#set_options
 UtilityFunction:
   exclude:
   - Reek::Spec

data/lib/reek/smell_warning.rb

@@ -1,4 +1,4 @@
-require 'reek/options'
+require 'reek/command_line'    # SMELL: Global Variable used for options
 
 module Reek
 
@@ -31,6 +31,10 @@ module Reek
     #
     def matches?(smell_class, patterns)
       return false unless smell_class.to_s == @detector.class.class_name
+      contains_all?(patterns)
+    end
+
+    def contains_all?(patterns)
       rpt = report
       return patterns.all? {|exp| exp === rpt}
     end

data/lib/reek/smells/duplication.rb

@@ -33,15 +33,17 @@ module Reek
       end
 
       def examine_context(method)
-        smelly_calls(method).each do |call|
-          found(method, "calls #{SexpFormatter.format(call)} multiple times")
+        smelly_calls(method).each do |call_data|
+          num = call_data[1]
+          multiple = num == 2 ? 'twice' : "#{num} times"
+          found(method, "calls #{SexpFormatter.format(call_data[0])} #{multiple}")
         end
       end
       
       def smelly_calls(method)   # :nodoc:
         method.calls.select do |key,val|
           val > @config[MAX_ALLOWED_CALLS_KEY] and key[2] != :new
-        end.map { |call_exp| call_exp[0] }
+        end
       end
     end
   end

data/lib/reek/smells/smell_detector.rb

@@ -46,7 +46,7 @@ module Reek
 
       def initialize(config = SmellDetector.default_config)
         @config = config
-        @smells_found = []
+        @smells_found = Set.new
         @masked = false
       end
 
@@ -99,6 +99,12 @@ module Reek
         smell
       end
 
+    def has_smell?(patterns)
+      return false if @masked
+      @smells_found.each { |warning| return true if warning.contains_all?(patterns) }
+      false
+    end
+
       def report_on(report)
         @smells_found.each do |smell|
           if @masked
@@ -109,6 +115,14 @@ module Reek
         end
       end
 
+      def num_smells
+        @masked ? 0 : @smells_found.length
+      end
+
+      def smelly?
+        (not @masked) and (@smells_found.length > 0)
+      end
+
       def smell_name
         self.class.name_words.join(' ')
       end

data/lib/reek/smells/uncommunicative_name.rb

@@ -20,7 +20,7 @@ module Reek
     class UncommunicativeName < SmellDetector
 
       # The name of the config field that lists the regexps of
-      # smelly names to be rejected.
+      # smelly names to be reported.
       REJECT_KEY = 'reject'
       
       # The name of the config field that lists the specific names that are

data/lib/reek/sniffer.rb

@@ -9,9 +9,7 @@ require 'reek/smells/long_yield_list'
 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
@@ -58,36 +56,27 @@ module Reek
       Smells::UtilityFunction,
     ]
 
-    attr_accessor :source
-
-    def initialize
+    def initialize(src)
+      @already_checked_for_smells = false
       @typed_detectors = nil
       @detectors = Hash.new
       SMELL_CLASSES.each { |klass| @detectors[klass] = DetectorStack.new(klass.new) }
+      @source = src
+      src.configure(self)
     end
 
-    #
-    # Configures this sniffer using any *.reek config files found
-    # on the path to the named file. Config files are applied in order,
-    # "root-first", so that config files closer to the named file override
-    # those further up the path.
-    #
-    def configure_along_path(filename)
-      path = File.expand_path(File.dirname(filename))
-      all_reekfiles(path).each { |config_file| ConfigFile.new(config_file).configure(self) }
-      self
+    def check_for_smells
+      return if @already_checked_for_smells
+      CodeParser.new(self).process(@source.syntax_tree)
+      @already_checked_for_smells = true
     end
 
     def configure(klass, config)
       @detectors[klass].push(config)
     end
 
-    def disable(klass)
-      disabled_config = {Reek::Smells::SmellDetector::ENABLED_KEY => false}
-      @detectors[klass].push(disabled_config)
-    end
-
     def report_on(report)
+      check_for_smells
       @detectors.each_value { |stack| stack.report_on(report) }
     end
 
@@ -96,36 +85,17 @@ 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
+      check_for_smells
+      @detectors.each_value { |stack| return true if stack.smelly? }
+      false
     end
 
     def num_smells
-      report.length
+      check_for_smells
+      total = 0
+      @detectors.each_value { |stack| total += stack.num_smells }
+      total
     end
 
     def desc
@@ -139,17 +109,23 @@ module Reek
     # 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)
+      check_for_smells
+      stack = @detectors[Reek::Smells.const_get(smell_class)]      # SMELL: Duplication of code in ConfigFile
+      stack.has_smell?(patterns)
     end
 
     def smells_only_of?(klass, patterns)
-      report.length == 1 and has_smell?(klass, patterns)
+      num_smells == 1 and has_smell?(klass, patterns)
     end
 
     def sniff
       self
     end
 
+    def sniffers
+      [self]
+    end
+
 private
 
     def smell_listeners()
@@ -159,18 +135,11 @@ private
       end
       @typed_detectors
     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
 
   class SnifferSet
 
-    attr_reader :sniffers, :desc
+    attr_reader :desc, :sniffers
 
     def initialize(sniffers, desc)
       @sniffers = sniffers
@@ -189,20 +158,19 @@ private
       @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)
+    def num_smells
+      total = 0
+      @sniffers.each {|sniffer| total += sniffer.num_smells}
+      total
     end
 
-    def quiet_report
-      ReportList.new(@sniffers).quiet_report
+    def smells_only_of?(klass, patterns)
+      num_smells == 1 and has_smell?(klass, patterns)
     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
+    def sniff
+      self
     end
+
   end
 end

data/lib/reek.rb

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