reek 1.1.3 → 1.2.0

data/lib/reek/adapters/config_file.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+
+module Reek
+  class ConfigFile
+
+    def initialize(file_path)
+      @file_path = file_path
+      @hash = YAML.load_file(@file_path) || {}
+      problem('not a Hash') unless Hash === @hash
+    end
+
+    #
+    # Configure the given sniffer using the contents of the config file.
+    #
+    def configure(sniffer)
+      @hash.each { |klass_name, config|
+        sniffer.configure(find_class(klass_name), config)
+      }
+    end
+
+    def find_class(name)
+      klass = Reek::Smells.const_get(name)
+      problem("#{name} is not a code smell") unless klass
+      klass
+    end
+
+    def problem(reason)
+      raise "Invalid configuration file \"#{File.basename(@file_path)}\" -- #{reason}"
+    end
+  end
+end

data/lib/reek/adapters/core_extras.rb

@@ -0,0 +1,72 @@
+require 'reek/adapters/source'
+require 'reek/sniffer'
+
+class Object
+  #
+  # Creates a new +Sniffer+ that assumes this object contains Ruby source
+  # code and examines that code for smells. Calls +to_reek_source+ on self
+  # to obtain the +Source+ object wrapper.
+  #
+  def sniff
+    Reek::Sniffer.new(self.to_reek_source)
+  end
+
+  #
+  # Constructs a Sniffer which examines this object for code smells.
+  # (This feature is only enabled if you have the ParseTree gem installed.)
+  #
+  def to_reek_source
+    ObjectSource.new(self, self.to_s)
+  end
+end
+
+class File
+  #
+  # Creates a new +Source+ that assumes this File contains Ruby source
+  # code and prepares it to be examined for code smells.
+  #
+  def to_reek_source
+    Reek::SourceFile.new(self)
+  end
+end
+
+class IO
+  #
+  # Creates a new +Source+ that assumes this IO stream contains Ruby source
+  # code and prepares it to be examined for code smells.
+  #
+  def to_reek_source(description = 'io')
+    Reek::Source.new(self.readlines.join, description)
+  end
+end
+
+class String
+  #
+  # Creates a new +Source+ that assumes this string contains Ruby source
+  # code and prepares it to be examined for code smells.
+  #
+  def to_reek_source
+    Reek::Source.new(self, 'string')
+  end
+end
+
+class Array
+  def paths
+    self.map do |path|
+      if test 'd', path
+        Dir["#{path}/**/*.rb"].paths
+      else
+        path
+      end
+    end.flatten.sort
+  end
+
+  #
+  # Creates a new +Sniffer+ that assumes this Array contains the names
+  # of Ruby source files and examines those files for smells.
+  #
+  def sniff
+    sniffers = paths.map {|path| File.new(path).sniff}
+    Reek::SnifferSet.new(sniffers, 'dir')
+  end
+end

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

@@ -1,15 +1,7 @@
-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
+require 'reek/adapters/source'
+require 'reek/configuration'
 
+module Reek
   class ObjectSource < Source   # :nodoc:
 
     def self.unify(sexp)   # :nodoc:
@@ -20,7 +12,13 @@ module Reek
       return unifier.process(sexp[0])
     end
 
-    def can_parse_objects?
+    def configure(sniffer)
+      super
+      disabled_config = {Reek::SmellConfiguration::ENABLED_KEY => false}
+      sniffer.configure(LargeClass, disabled_config)
+    end
+
+    def self.can_parse_objects?
       return true if Object.const_defined?(:ParseTree)
       begin
         require 'parse_tree'
@@ -30,8 +28,8 @@ module Reek
       end
     end
 
-    def generate_syntax_tree
-      if can_parse_objects?
+    def syntax_tree
+      if ObjectSource.can_parse_objects?
         ObjectSource.unify(ParseTree.new.parse_tree(@source))
       else
         throw ArgumentError.new('You must install the ParseTree gem to use this feature')
@@ -42,12 +40,10 @@ 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 to_reek_source
+    ObjectSource.new(self, self.to_s)
   end
 end

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

@@ -59,7 +59,7 @@ module Reek
     # Defines a new task, using the name +name+.
     def initialize(name = :reek)
       @name = name
-      @libs = [File.expand_path(File.dirname(__FILE__) + '/../../lib')]
+      @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
       @source_files = nil
       @ruby_opts = []
       @reek_opts = ''
@@ -87,7 +87,7 @@ private
     end
 
     def self.reek_script
-      File.expand_path(File.dirname(__FILE__) + '/../../bin/reek')
+      File.expand_path(File.dirname(__FILE__) + '/../../../bin/reek')
     end
 
     def self.ruby_exe

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,53 @@
+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 self.lines(file)
+      IO.readlines(file.path)
+    end
+
+    def initialize(file)
+      @file = file
+      super(SourceFile.lines(@file).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/source'
+require 'reek/sniffer'
+require 'reek/adapters/core_extras'
+require 'reek/adapters/object_source'
+require 'reek/adapters/report'
 
 module Reek
 
@@ -34,75 +37,83 @@ module Reek
   # And a more complex example, making use of one of the factory methods for
   # +Source+ so that the code is parsed and analysed only once:
   # 
-  #   ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'.to_source
+  #   ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'.sniff
   #   ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
   #   ruby.should reek_of(:Duplication, /@other.thing.foo/)
   #   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)
-        @source = actual.to_source
-        @source.smelly?
+        @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#{@source.report}"
+        "Expected no smells, but got:\n#{report}"
       end
     end
 
-    #
-    # Returns +true+ if and only if the target source code contains smells.
-    #
-    def reek
-      ShouldReek.new
-    end
-
     class ShouldReekOf        # :nodoc:
+      include ReekMatcher
+
       def initialize(klass, patterns)
         @klass = klass
         @patterns = patterns
       end
       def matches?(actual)
-        @source = actual.to_source
-        @source.has_smell?(@klass, @patterns)
+        @sniffer = actual.sniff
+        @sniffer.has_smell?(@klass, @patterns)
       end
       def failure_message_for_should
-        "Expected #{@source} to reek of #{@klass}, but it didn't"
+        "Expected #{@sniffer.desc} to reek of #{@klass}, but it didn't"
       end
       def failure_message_for_should_not
-        "Expected #{@source} not to reek of #{@klass}, but got:\n#{@source.report}"
+        "Expected #{@sniffer.desc} not to reek of #{@klass}, but got:\n#{report}"
       end
     end
 
-    #
-    # Checks the target source code for instances of +smell_class+,
-    # and returns +true+ only if one of them has a report string matching
-    # all of the +patterns+.
-    #
-    def reek_of(smell_class, *patterns)
-      ShouldReekOf.new(smell_class, patterns)
-    end
+    class ShouldReekOnlyOf < ShouldReekOf        # :nodoc:
+      include ReekMatcher
 
-    class ShouldReekOnlyOf        # :nodoc:
-      def initialize(klass, patterns)
-        @klass = klass
-        @patterns = patterns
-      end
       def matches?(actual)
-        @source = actual.to_source
-        @source.report.length == 1 and @source.has_smell?(@klass, @patterns)
+        @sniffer = actual.sniff
+        @sniffer.smells_only_of?(@klass, @patterns)
       end
       def failure_message_for_should
-        "Expected source to reek only of #{@klass}, but got:\n#{@source.report}"
+        "Expected #{@sniffer.desc} to reek only of #{@klass}, but got:\n#{report}"
       end
       def failure_message_for_should_not
-        "Expected source not to reek only of #{@klass}, but it did"
+        "Expected #{@sniffer.desc} not to reek only of #{@klass}, but it did"
       end
     end
 
+    #
+    # Returns +true+ if and only if the target source code contains smells.
+    #
+    def reek
+      ShouldReek.new
+    end
+
+    #
+    # Checks the target source code for instances of +smell_class+,
+    # and returns +true+ only if one of them has a report string matching
+    # all of the +patterns+.
+    #
+    def reek_of(smell_class, *patterns)
+      ShouldReekOf.new(smell_class, patterns)
+    end
+
     #
     # As for reek_of, but the matched smell warning must be the only warning of
     # any kind in the target source code's Reek report.
@@ -113,32 +124,6 @@ module Reek
   end
 end
 
-class File
-  def to_source
-    Reek::Source.from_f(self)
-  end
-end
-
-class String
-  def to_source
-    Reek::Source.from_s(self)
-  end
-end
-
-class Array
-  def to_source
-    Reek::Source.from_pathlist(self)
-  end
-end
-
-module Reek
-  class Source
-    def to_source
-      self
-    end
-  end
-end
-
 if Object.const_defined?(:Spec)
   Spec::Runner.configure do |config|
     config.include(Reek::Spec)