reek 1.6.6 → 2.0.0

data/lib/reek/smell_warning.rb

@@ -34,36 +34,51 @@ module Reek
       (self <=> other) == 0
     end
 
-    def matches?(klass, patterns)
-      smell_classes.include?(klass.to_s) && contains_all?(patterns)
+    def matches?(klass, other_parameters = {})
+      smell_classes.include?(klass.to_s) && common_parameters_equal?(other_parameters)
     end
 
     def report_on(listener)
       listener.found_smell(self)
     end
 
-    def encode_with(coder)
-      coder.tag = nil
-      coder['smell_category']  = smell_detector.smell_category
-      coder['smell_type']      = smell_detector.smell_type
-      coder['source']          = smell_detector.source
-      coder['context']         = context
-      coder['lines']           = lines
-      coder['message']         = message
+    def yaml_hash
+      result = {
+        'smell_category' => smell_detector.smell_category,
+        'smell_type'     => smell_detector.smell_type,
+        'source'         => smell_detector.source,
+        'context'        => context,
+        'lines'          => lines,
+        'message'        => message
+      }
       parameters.each do |key, value|
-        coder[key.to_s] = value
+        result[key.to_s] = value
       end
+      result
     end
 
     protected
 
-    def contains_all?(patterns)
-      rpt = sort_key.to_s
-      patterns.all? { |pattern| pattern =~ rpt }
-    end
-
     def sort_key
       [context, message, smell_category]
     end
+
+    def common_parameters_equal?(other_parameters)
+      other_parameters.keys.each do |key|
+        unless parameters.key?(key)
+          raise ArgumentError, "The parameter #{key} you want to check for doesn't exist"
+        end
+      end
+
+      # Why not check for strict parameter equality instead of just the common ones?
+      #
+      # In `self`, `parameters` might look like this:  {:name=>"@other.thing", :count=>2}
+      # Coming from specs, 'other_parameters' might look like this, e.g.:
+      # {:name=>"@other.thing"}
+      # So in this spec we are just specifying the "name" parameter but not the "count".
+      # In order to allow for this kind of leniency we just test for common parameter equality,
+      # not for a strict one.
+      parameters.values_at(*other_parameters.keys) == other_parameters.values
+    end
   end
 end

data/lib/reek/smells/nested_iterators.rb

@@ -39,7 +39,7 @@ module Reek
                             context: ctx.full_name,
                             lines: [exp.line],
                             message: "contains iterators nested #{depth} deep",
-                            parameters: { count: depth })]
+                            parameters: { name: ctx.full_name, count: depth })]
         else
           []
         end

data/lib/reek/smells/smell_detector.rb

@@ -36,6 +36,15 @@ module Reek
             EXCLUDE_KEY => DEFAULT_EXCLUDE_SET.dup
           }
         end
+
+        def inherited(subclass)
+          @subclasses ||= []
+          @subclasses << subclass
+        end
+
+        def descendants
+          @subclasses
+        end
       end
 
       def smell_category

data/lib/reek/smells/utility_function.rb

@@ -69,7 +69,8 @@ module Reek
         [SmellWarning.new(self,
                           context: method_ctx.full_name,
                           lines: [method_ctx.exp.line],
-                          message: "doesn't depend on instance state")]
+                          message: "doesn't depend on instance state",
+                          parameters: { name: method_ctx.full_name })]
       end
 
       private

data/lib/reek/spec/should_reek.rb

@@ -1,7 +1,5 @@
 require 'reek/examiner'
-require 'reek/cli/report/report'
 require 'reek/cli/report/formatter'
-require 'reek/cli/report/strategy'
 
 module Reek
   module Spec
@@ -23,7 +21,6 @@ module Reek
         "Expected no smells, but got:\n#{rpt}"
       end
     end
-
     #
     # Returns +true+ if and only if the target source code contains smells.
     #

data/lib/reek/spec/should_reek_of.rb

@@ -6,34 +6,83 @@ module Reek
     # An rspec matcher that matches when the +actual+ has the specified
     # code smell.
     #
-    class ShouldReekOf        # :nodoc:
-      def initialize(klass, patterns)
-        @klass = klass
-        @patterns = patterns
+    class ShouldReekOf
+      def initialize(smell_category, smell_details = {})
+        @smell_category = normalize smell_category
+        @smell_details  = smell_details
       end
 
       def matches?(actual)
         @examiner = Examiner.new(actual)
         @all_smells = @examiner.smells
-        @all_smells.any? { |warning| warning.matches?(@klass, @patterns) }
+        @all_smells.any? { |warning| warning.matches?(@smell_category, @smell_details) }
       end
 
       def failure_message
-        "Expected #{@examiner.description} to reek of #{@klass}, but it didn't"
+        "Expected #{@examiner.description} to reek of #{@smell_category}, but it didn't"
       end
 
       def failure_message_when_negated
-        "Expected #{@examiner.description} not to reek of #{@klass}, but it did"
+        "Expected #{@examiner.description} not to reek of #{@smell_category}, but it did"
+      end
+
+      private
+
+      def normalize(smell_category_or_type)
+        # In theory, users can give us many different types of input (see the documentation for
+        # reek_of below), however we're basically ignoring all of those subleties and just
+        # return a string with the prepending namespace stripped.
+        smell_category_or_type.to_s.split(/::/)[-1]
       end
     end
 
     #
-    # Checks the target source code for instances of +smell_category+,
-    # and returns +true+ only if one of them has a report string matching
-    # all of the +patterns+.
+    # Checks the target source code for instances of "smell category"
+    # and returns true only if it can find one of them that matches.
+    #
+    # Remember that this includes our "smell types" as well. So it could be the
+    # "smell type" UtilityFunction, which is represented as a concrete class
+    # in reek but it could also be "Duplication" which is a "smell categgory".
+    #
+    # In theory you could pass many different types of input here:
+    #   - :UtilityFunction
+    #   - "UtilityFunction"
+    #   - UtilityFunction (this works in our specs because we tend to do "include Reek:Smells")
+    #   - Reek::Smells::UtilityFunction (the right way if you really want to pass a class)
+    #   - "Duplication" or :Duplication which is an abstract "smell category"
+    #
+    # It is recommended to pass this as a symbol like :UtilityFunction. However we don't
+    # enforce this.
+    #
+    # Additionally you can be more specific and pass in "smell_details" you
+    # want to check for as well e.g. "name" or "count" (see the examples below).
+    # The parameters you can check for are depending on the smell you are checking for.
+    # For instance "count" doesn't make sense everywhere whereas "name" does in most cases.
+    # If you pass in a parameter that doesn't exist (e.g. you make a typo like "namme") reek will
+    # raise an ArgumentError to give you a hint that you passed something that doesn't make
+    # much sense.
+    #
+    # smell_category - The "smell category" or "smell_type" we check for.
+    # smells_details - A hash containing "smell warning" parameters
+    #
+    # Examples
+    #
+    #   Without smell_details:
+    #
+    #   reek_of(:FeatureEnvy)
+    #   reek_of(Reek::Smells::UtilityFunction)
+    #
+    #   With smell_details:
+    #
+    #   reek_of(UncommunicativeParameterName, name: 'x2')
+    #   reek_of(DataClump, count: 3)
+    #
+    # Examples from a real spec
+    #
+    #   expect(src).to reek_of(Reek::Smells::DuplicateMethodCall, name: '@other.thing')
     #
-    def reek_of(smell_category, *patterns)
-      ShouldReekOf.new(smell_category, patterns)
+    def reek_of(smell_category, smell_details = {})
+      ShouldReekOf.new(smell_category, smell_details)
     end
   end
 end

data/lib/reek/spec/should_reek_only_of.rb

@@ -1,7 +1,5 @@
 require 'reek/examiner'
-require 'reek/cli/report/report'
 require 'reek/cli/report/formatter'
-require 'reek/cli/report/strategy'
 
 module Reek
   module Spec
@@ -9,7 +7,7 @@ module Reek
     # An rspec matcher that matches when the +actual+ has the specified
     # code smell and no others.
     #
-    class ShouldReekOnlyOf < ShouldReekOf        # :nodoc:
+    class ShouldReekOnlyOf < ShouldReekOf
       def matches?(actual)
         matches_examiner?(Examiner.new(actual))
       end
@@ -17,25 +15,29 @@ module Reek
       def matches_examiner?(examiner)
         @examiner = examiner
         @warnings = @examiner.smells
-        @warnings.length == 1 && @warnings[0].matches?(@klass, @patterns)
+        return false if @warnings.empty?
+        @warnings.all? { |warning| warning.matches?(@smell_category) }
       end
 
       def failure_message
         rpt = Cli::Report::Formatter.format_list(@warnings)
-        "Expected #{@examiner.description} to reek only of #{@klass}, but got:\n#{rpt}"
+        "Expected #{@examiner.description} to reek only of #{@smell_category}, but got:\n#{rpt}"
       end
 
       def failure_message_when_negated
-        "Expected #{@examiner.description} not to reek only of #{@klass}, but it did"
+        "Expected #{@examiner.description} not to reek only of #{@smell_category}, but it did"
       end
     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.
+    # See the documentaton for "reek_of".
     #
-    def reek_only_of(smell_category, *patterns)
-      ShouldReekOnlyOf.new(smell_category, patterns)
+    # Notable differences to reek_of:
+    #   1.) "reek_of" doesn't mind if there are other smells of a different category.
+    #       "reek_only_of" will fail in that case.
+    #   2.) "reek_only_of" doesn't support the additional smell_details hash.
+    def reek_only_of(smell_category)
+      ShouldReekOnlyOf.new(smell_category)
     end
   end
 end

data/lib/reek/version.rb

@@ -1,3 +1,3 @@
 module Reek
-  VERSION = '1.6.6'
+  VERSION = '2.0.0'
 end

data/reek.gemspec

@@ -30,9 +30,9 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.3'
   s.summary = 'Code smell detector for Ruby'
 
-  s.add_runtime_dependency('parser', ['~> 2.2.0.pre.7'])
+  s.add_runtime_dependency('parser', ['~> 2.2'])
   s.add_runtime_dependency('unparser', ['~> 0.2.2'])
-  s.add_runtime_dependency('rainbow', ['>= 1.99', '< 3.0'])
+  s.add_runtime_dependency('rainbow', ['~> 2.0'])
 
   s.add_development_dependency('bundler', ['~> 1.1'])
   s.add_development_dependency('rake', ['~> 10.0'])

data/spec/factories/factories.rb

@@ -7,10 +7,7 @@ FactoryGirl.define do
     source 'dummy_file'
 
     initialize_with do
-      # The odd looking const_get is necessary for ruby 1.9.3 compatibility.
-      Kernel.const_get('Reek').
-        const_get('Smells').
-        const_get(smell_type).new(source)
+      ::Reek::Smells.const_get(smell_type).new(source)
     end
   end
 
@@ -20,7 +17,7 @@ FactoryGirl.define do
     context 'self'
     lines [42]
     message 'smell warning message'
-    parameters     {}
+    parameters { {} }
 
     initialize_with do
       new(smell_detector, context: context,

data/spec/reek/cli/html_report_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'reek/examiner'
+require 'reek/cli/report/report'
+
+include Reek
+include Reek::Cli
+
+describe Report::HtmlReport do
+  let(:instance) { Report::HtmlReport.new }
+
+  context 'with an empty source' do
+    let(:examiner) { Examiner.new('') }
+
+    before do
+      instance.add_examiner examiner
+    end
+
+    it 'has the text 0 total warnings' do
+      instance.show
+
+      file = File.expand_path('../../../../reek.html', __FILE__)
+      text = File.read(file)
+      File.delete(file)
+
+      expect(text).to include('0 total warnings')
+    end
+  end
+end

data/spec/reek/cli/option_interperter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+require 'reek/cli/options'
+
+describe Reek::Cli::OptionInterpreter do
+  let(:options) { OpenStruct.new }
+  let(:instance) { Reek::Cli::OptionInterpreter.new(options) }
+
+  describe '#reporter' do
+    it 'returns a Report::TextReport instance by default' do
+      expect(instance.reporter).to be_instance_of Reek::Cli::Report::TextReport
+    end
+  end
+end

data/spec/reek/cli/text_report_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'reek/examiner'
+require 'reek/cli/report/report'
+require 'reek/cli/report/formatter'
+require 'reek/cli/report/heading_formatter'
+require 'rainbow'
+
+include Reek
+include Reek::Cli
+
+describe Report::TextReport do
+  let(:report_options) do
+    {
+      warning_formatter: Report::SimpleWarningFormatter.new,
+      report_formatter: Report::Formatter,
+      heading_formatter: Report::HeadingFormatter::Quiet
+    }
+  end
+  let(:instance) { Report::TextReport.new report_options }
+
+  context 'with a single empty source' do
+    before do
+      instance.add_examiner Examiner.new('')
+    end
+
+    it 'has an empty quiet_report' do
+      expect { instance.show }.to_not output.to_stdout
+    end
+  end
+
+  context 'with non smelly files' do
+    before do
+      instance.add_examiner(Examiner.new('def simple() puts "a" end'))
+      instance.add_examiner(Examiner.new('def simple() puts "a" end'))
+    end
+
+    context 'with colors disabled' do
+      before :each do
+        Rainbow.enabled = false
+      end
+
+      it 'shows total of 0 warnings' do
+        expect { instance.show }.to output(/0 total warnings\n\Z/).to_stdout
+      end
+    end
+
+    context 'with colors enabled' do
+      before :each do
+        Rainbow.enabled = true
+      end
+
+      it 'has a footer in color' do
+        expect { instance.show }.to output(/\e\[32m0 total warnings\n\e\[0m\Z/).to_stdout
+      end
+    end
+  end
+
+  context 'with a couple of smells' do
+    before do
+      instance.add_examiner(Examiner.new('def simple(a) a[3] end'))
+      instance.add_examiner(Examiner.new('def simple(a) a[3] end'))
+    end
+
+    context 'with colors disabled' do
+      before do
+        Rainbow.enabled = false
+      end
+
+      it 'has a heading' do
+        expect { instance.show }.to output(/string -- 2 warnings/).to_stdout
+      end
+
+      it 'should mention every smell name' do
+        expect { instance.show }.to output(/UncommunicativeParameterName/).to_stdout
+        expect { instance.show }.to output(/FeatureEnvy/).to_stdout
+      end
+    end
+
+    context 'with colors enabled' do
+      before do
+        Rainbow.enabled = true
+      end
+
+      it 'has a header in color' do
+        expect { instance.show }.
+          to output(/\A\e\[36mstring -- \e\[0m\e\[33m2 warning\e\[0m\e\[33ms\e\[0m/).to_stdout
+      end
+
+      it 'has a footer in color' do
+        expect { instance.show }.
+          to output(/\e\[31m4 total warnings\n\e\[0m\Z/).to_stdout
+      end
+    end
+  end
+end