reek 4.5.0 → 4.6.0

data/lib/reek/detector_repository.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require_relative 'smell_detectors'
+require_relative 'smell_detectors/base_detector'
+require_relative 'configuration/app_configuration'
+
+module Reek
+  #
+  # Contains all the existing smell detectors and exposes operations on them.
+  #
+  class DetectorRepository
+    # @return [Array<Reek::SmellDetectors::BaseDetector>] All known SmellDetectors
+    #         e.g. [Reek::SmellDetectors::BooleanParameter, Reek::SmellDetectors::ClassVariable].
+    def self.smell_types
+      Reek::SmellDetectors::BaseDetector.descendants.sort_by(&:name)
+    end
+
+    # @param filter_by_smells [Array<String>]
+    #   List of smell types to filter by, e.g. "DuplicateMethodCall".
+    #   More precisely it should be whatever is returned by `BaseDetector`.smell_type.
+    #   This means that you can write the "DuplicateMethodCall" from above also like this:
+    #     Reek::SmellDetectors::DuplicateMethodCall.smell_type
+    #   if you want to make sure you do not fat-finger strings.
+    #
+    # @return [Array<Reek::SmellDetectors::BaseDetector>] All SmellDetectors that we want to filter for
+    #         e.g. [Reek::SmellDetectors::Attribute].
+    def self.eligible_smell_types(filter_by_smells = [])
+      return smell_types if filter_by_smells.empty?
+      smell_types.select do |klass|
+        filter_by_smells.include? klass.smell_type
+      end
+    end
+
+    def initialize(smell_types: self.class.smell_types,
+                   configuration: {})
+      @configuration = configuration
+      @smell_types   = smell_types
+      @detectors     = smell_types.map { |klass| klass.new configuration_for(klass) }
+    end
+
+    def examine(context)
+      smell_detectors_for(context.type).flat_map do |detector|
+        detector.run_for(context)
+      end
+    end
+
+    private
+
+    attr_reader :configuration, :smell_types, :detectors
+
+    def configuration_for(klass)
+      configuration.fetch klass, {}
+    end
+
+    def smell_detectors_for(type)
+      enabled_detectors.select do |detector|
+        detector.contexts.include? type
+      end
+    end
+
+    def enabled_detectors
+      detectors.select { |detector| detector.config.enabled? }
+    end
+  end
+end

data/lib/reek/errors/bad_detector_configuration_key_in_comment_error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative 'base_error'
+
+module Reek
+  module Errors
+    # Gets raised when trying to configure a detector with an option
+    # which is unknown to it.
+    class BadDetectorConfigurationKeyInCommentError < BaseError
+      UNKNOWN_SMELL_DETECTOR_MESSAGE = <<-EOS.freeze
+
+        Error: You are trying to configure the smell detector '%s'
+        in one of your source code comments with the unknown option %s.
+        The source is '%s' and the comment belongs to the expression starting in line %d.
+        Here's the original comment:
+
+        %s
+
+        Please see the Reek docs for:
+          * how to configure Reek via source code comments: https://github.com/troessner/reek/blob/master/docs/Smell-Suppression.md
+          * what basic options are available: https://github.com/troessner/reek/blob/master/docs/Basic-Smell-Options.md
+          * what custom options are available by checking the detector specific documentation in /docs
+        Update the offensive comment (or remove it if no longer applicable) and re-run Reek.
+
+      EOS
+
+      def initialize(detector_name:, offensive_keys:, source:, line:, original_comment:)
+        message = format(UNKNOWN_SMELL_DETECTOR_MESSAGE,
+                         detector_name,
+                         offensive_keys,
+                         source,
+                         line,
+                         original_comment)
+        super message
+      end
+    end
+  end
+end

data/lib/reek/errors/bad_detector_in_comment_error.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+require_relative 'base_error'
 
 module Reek
   module Errors
     # Gets raised when trying to configure a detector which is unknown to us.
     # This might happen for multiple reasons. The users might have a typo in
     # his comment or he might use a detector that does not exist anymore.
-    class BadDetectorInCommentError < RuntimeError
+    class BadDetectorInCommentError < BaseError
       UNKNOWN_SMELL_DETECTOR_MESSAGE = <<-EOS.freeze
 
         Error: You are trying to configure an unknown smell detector '%s' in one

data/lib/reek/errors/base_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Reek
+  module Errors
+    # Base class for all runtime Reek errors
+    class BaseError < ::RuntimeError
+    end
+  end
+end

data/lib/reek/errors/garbage_detector_configuration_in_comment_error.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+require_relative 'base_error'
 
 module Reek
   module Errors
     # Gets raised when trying to use a configuration for a detector
     # that can't be parsed into a hash.
-    class GarbageDetectorConfigurationInCommentError < RuntimeError
+    class GarbageDetectorConfigurationInCommentError < BaseError
       BAD_DETECTOR_CONFIGURATION_MESSAGE = <<-EOS.freeze
 
         Error: You are trying to configure the smell detector '%s'.

data/lib/reek/errors/incomprehensible_source_error.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative 'base_error'
+
+module Reek
+  module Errors
+    # Gets raised when Reek is unable to process the source
+    class IncomprehensibleSourceError < BaseError
+      INCOMPREHENSIBLE_SOURCE_TEMPLATE = <<-EOS.freeze
+        !!!
+        Source %s can not be processed by Reek.
+
+        This is most likely either a bug in your Reek configuration (config file or
+        source code comments) or a Reek bug.
+
+        Please double check your Reek configuration taking the original exception
+        below into account -  you might have misspelled a smell detector for instance.
+        (In the future Reek will handle configuration errors more gracefully, something
+        we are working on already).
+
+        If you feel that this is not a problem with your Reek configuration but with
+        Reek itself it would be great if you could report this back to the Reek
+        team by opening up a corresponding issue at https://github.com/troessner/reek/issues.
+
+        Please make sure to include the source in question, the Reek version
+        and the original exception below.
+
+        Exception message:
+
+        %s
+
+        Original exception:
+
+        %s
+
+        !!!
+      EOS
+
+      def initialize(origin:, original_exception:)
+        message = format(INCOMPREHENSIBLE_SOURCE_TEMPLATE,
+                         origin,
+                         original_exception.message,
+                         original_exception.backtrace.join("\n\t"))
+        super message
+      end
+    end
+  end
+end

data/lib/reek/errors/parse_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require_relative 'base_error'
+
+module Reek
+  module Errors
+    # Gets raised when Reek is unable to process the source
+    class ParseError < BaseError
+      MESSAGE_TEMPLATE = '%s: %s: %s'.freeze
+
+      def initialize(origin:, original_exception:)
+        message = format(MESSAGE_TEMPLATE,
+                         origin,
+                         original_exception.class.name,
+                         original_exception.message)
+        super message
+      end
+    end
+  end
+end

data/lib/reek/examiner.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require_relative 'context_builder'
-require_relative 'errors/bad_detector_in_comment_error'
-require_relative 'errors/garbage_detector_configuration_in_comment_error'
-require_relative 'smell_detectors/detector_repository'
+require_relative 'detector_repository'
+require_relative 'errors/incomprehensible_source_error'
 require_relative 'source/source_code'
 
 module Reek
@@ -11,35 +10,13 @@ module Reek
   #
   # @public
   class Examiner
-    INCOMPREHENSIBLE_SOURCE_TEMPLATE = <<-EOS.freeze
-      !!!
-      Source %s can not be processed by Reek.
-
-      This is most likely either a bug in your Reek configuration (config file or
-      source code comments) or a Reek bug.
-
-      Please double check your Reek configuration taking the original exception
-      below into account -  you might have misspelled a smell detector for instance.
-      (In the future Reek will handle configuration errors more gracefully, something
-      we are working on already).
-
-      If you feel that this is not a problem with your Reek configuration but with
-      Reek itself it would be great if you could report this back to the Reek
-      team by opening up a corresponding issue at https://github.com/troessner/reek/issues.
-
-      Please make sure to include the source in question, the Reek version
-      and the original exception below.
-
-      Exception message:
-
-      %s
-
-      Original exception:
-
-      %s
+    # Handles no errors
+    class NullHandler
+      def handle(_exception)
+        false
+      end
+    end
 
-      !!!
-    EOS
     #
     # Creates an Examiner which scans the given +source+ for code smells.
     #
@@ -57,11 +34,13 @@ module Reek
     def initialize(source,
                    filter_by_smells: [],
                    configuration: Configuration::AppConfiguration.default,
-                   detector_repository_class: SmellDetectors::DetectorRepository)
+                   detector_repository_class: DetectorRepository,
+                   error_handler: NullHandler.new)
       @source              = Source::SourceCode.from(source)
       @smell_types         = detector_repository_class.eligible_smell_types(filter_by_smells)
       @detector_repository = detector_repository_class.new(smell_types: @smell_types,
                                                            configuration: configuration.directive_for(description))
+      @error_handler       = error_handler
     end
 
     # @return [String] origin of the source being analysed
@@ -120,15 +99,8 @@ module Reek
       return [] unless syntax_tree
       begin
         examine_tree
-      rescue Errors::BadDetectorInCommentError,
-             Errors::GarbageDetectorConfigurationInCommentError => exception
-        warn exception
-        []
-      rescue StandardError => exception
-        warn format(INCOMPREHENSIBLE_SOURCE_TEMPLATE,
-                    origin,
-                    exception.message,
-                    exception.backtrace.join("\n\t"))
+      rescue Errors::BaseError => exception
+        raise unless @error_handler.handle exception
         []
       end
     end
@@ -141,6 +113,10 @@ module Reek
       ContextBuilder.new(syntax_tree).context_tree.flat_map do |element|
         detector_repository.examine(element)
       end
+    rescue Errors::BaseError
+      raise
+    rescue StandardError => exception
+      raise Errors::IncomprehensibleSourceError, origin: origin, original_exception: exception
     end
   end
 end

data/lib/reek/logging_error_handler.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require_relative 'errors/bad_detector_configuration_key_in_comment_error'
+require_relative 'errors/bad_detector_in_comment_error'
+require_relative 'errors/garbage_detector_configuration_in_comment_error'
+require_relative 'errors/incomprehensible_source_error'
+
+module Reek
+  # Handles errors by logging to stderr
+  class LoggingErrorHandler
+    def handle(exception)
+      warn exception
+      true
+    end
+  end
+end

data/lib/reek/report/code_climate/code_climate_configuration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Reek
+  module Report
+    # loads the smell type metadata to present in Code Climate
+    module CodeClimateConfiguration
+      def self.load
+        config_file = File.expand_path('../code_climate_configuration.yml', __FILE__)
+        YAML.load_file config_file
+      end
+    end
+  end
+end

data/lib/reek/report/code_climate/code_climate_configuration.yml

@@ -222,6 +222,135 @@ FeatureEnvy:
     ```
 
     belongs to the Item class, not the Warehouse.
+InstanceVariableAssumption:
+  remediation_points: 350_000
+  content: |
+    Classes should not assume that instance variables are set or present outside of the current class definition.
+
+    Good:
+
+    ```Ruby
+    class Foo
+      def initialize
+        @bar = :foo
+      end
+
+      def foo?
+        @bar == :foo
+      end
+    end
+    ```
+
+    Good as well:
+
+    ```Ruby
+    class Foo
+      def foo?
+        bar == :foo
+      end
+
+      def bar
+        @bar ||= :foo
+      end
+    end
+    ```
+
+    Bad:
+
+    ```Ruby
+    class Foo
+      def go_foo!
+        @bar = :foo
+      end
+
+      def foo?
+        @bar == :foo
+      end
+    end
+    ```
+
+    ## Example
+
+    Running Reek on:
+
+    ```Ruby
+    class Dummy
+      def test
+        @ivar
+      end
+    end
+    ```
+
+    would report:
+
+    ```Bash
+      [1]:InstanceVariableAssumption: Dummy assumes too much for instance variable @ivar [https://github.com/troessner/reek/blob/master/docs/Instance-Variable-Assumption.md]
+    ```
+
+    Note that this example would trigger this smell warning as well:
+
+    ```Ruby
+    class Parent
+      def initialize(omg)
+        @omg = omg
+      end
+    end
+
+    class Child < Parent
+      def foo
+        @omg
+      end
+    end
+    ```
+
+    The way to address the smell warning is that you should create an `attr_reader` to use `@omg` in the subclass and not access `@omg` directly like this:
+
+    ```Ruby
+    class Parent
+      attr_reader :omg
+
+      def initialize(omg)
+        @omg = omg
+      end
+    end
+
+    class Child < Parent
+      def foo
+        omg
+      end
+    end
+    ```
+
+    Directly accessing instance variables is considered a smell because it [breaks encapsulation](http://designisrefactoring.com/2015/03/29/organizing-data-self-encapsulation/) and makes it harder to reason about code.
+
+    If you don't want to expose those methods as public API just make them private like this:
+
+    ```Ruby
+    class Parent
+      def initialize(omg)
+        @omg = omg
+      end
+
+      private
+      attr_reader :omg
+    end
+
+    class Child < Parent
+      def foo
+        omg
+      end
+    end
+    ```
+
+
+    ## Current Support in Reek
+
+    An instance variable must:
+
+    * be set in the constructor
+    * or be accessed through a method with lazy initialization / memoization.
+
+    If not, _Instance Variable Assumption_ will be reported.
 IrresponsibleModule:
   remediation_points: 350_000
   content: |
@@ -300,6 +429,33 @@ LongYieldList:
     ```
 
     A common solution to this problem would be the introduction of parameter objects.
+ManualDispatch:
+  remediation_points: 350_000
+  content: |
+    Reek reports a _Manual Dispatch_ smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of Simulated Polymorphism which leads to code that is harder to reason about, debug, and refactor.
+
+    ## Example
+
+    ```Ruby
+    class MyManualDispatcher
+      attr_reader :foo
+
+      def initialize(foo)
+        @foo = foo
+      end
+
+      def call
+        foo.bar if foo.respond_to?(:bar)
+      end
+    end
+    ```
+
+    Reek would emit the following warning:
+
+    ```
+    test.rb -- 1 warning:
+      [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)
+    ```
 ModuleInitialize:
   remediation_points: 350_000
   content: |

data/lib/reek/report/code_climate/code_climate_fingerprint.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'digest'
+
 module Reek
   module Report
     # Generates a string to uniquely identify a smell
@@ -14,7 +16,7 @@ module Reek
 
         identify_warning
 
-        identifying_aspects.hexdigest
+        identifying_aspects.hexdigest.freeze
       end
 
       private
@@ -33,7 +35,7 @@ module Reek
       end
 
       def parameters
-        warning.parameters.except(*NON_IDENTIFYING_PARAMETERS).sort.to_s
+        warning.parameters.reject { |key, _| NON_IDENTIFYING_PARAMETERS.include?(key) }.sort.to_s
       end
 
       def warning_uniquely_identifiable?

data/lib/reek/report/code_climate/code_climate_formatter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'codeclimate_engine'
+require_relative 'code_climate_configuration'
 
 module Reek
   module Report
@@ -56,8 +57,7 @@ module Reek
 
       def configuration
         @configuration ||= begin
-          config_file = File.expand_path('../code_climate_configuration.yml', __FILE__)
-          YAML.load_file config_file
+          CodeClimateConfiguration.load
         end
       end
     end

data/lib/reek/smell_configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+module Reek
+  #
+  # Represents a single set of configuration options for a smell detector
+  #
+  class SmellConfiguration
+    # The name of the config field that specifies whether a smell is
+    # enabled. Set to +true+ or +false+.
+    ENABLED_KEY = 'enabled'.freeze
+
+    # The name of the config field that sets scope-specific overrides
+    # for other values in the current smell detector's configuration.
+    OVERRIDES_KEY = 'overrides'.freeze
+
+    def initialize(hash)
+      @options = hash
+    end
+
+    def merge(new_options)
+      options.merge!(new_options)
+    end
+
+    def enabled?
+      options[ENABLED_KEY]
+    end
+
+    def overrides_for(context)
+      Overrides.new(options.fetch(OVERRIDES_KEY, {})).for_context(context)
+    end
+
+    # Retrieves the value, if any, for the given +key+ in the given +context+.
+    #
+    # Raises an error if neither the context nor this config have a value for
+    # the key.
+    #
+    def value(key, context)
+      overrides_for(context).each { |conf| return conf[key] if conf.key?(key) }
+      options.fetch(key)
+    end
+
+    private
+
+    attr_reader :options
+  end
+
+  #
+  # A set of context-specific overrides for smell detectors.
+  #
+  class Overrides
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # Find any overrides that match the supplied context
+    def for_context(context)
+      contexts = hash.keys.select { |ckey| context.matches?([ckey]) }
+      contexts.map { |exc| hash[exc] }
+    end
+
+    private
+
+    attr_reader :hash
+  end
+end

data/lib/reek/smell_detectors/attribute.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
-require_relative 'smell_configuration'
 require_relative 'base_detector'
-require_relative 'smell_warning'
 
 module Reek
   module SmellDetectors

data/lib/reek/smell_detectors/base_detector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'set'
-require_relative 'smell_configuration'
+require_relative '../smell_warning'
+require_relative '../smell_configuration'
 
 module Reek
   module SmellDetectors
@@ -14,6 +15,7 @@ module Reek
     # for details.
     #
     # :reek:UnusedPrivateMethod: { exclude: [ smell_warning ] }
+    # :reek:TooManyMethods: { max_methods: 18 }
     class BaseDetector
       attr_reader :config
       # The name of the config field that lists the names of code contexts
@@ -105,9 +107,9 @@ module Reek
         # Returns all descendants of BaseDetector
         #
         # @return [Array<Constant>], e.g.:
-        #   [Reek::Smells::Attribute,
-        #    Reek::Smells::BooleanParameter,
-        #    Reek::Smells::ClassVariable,
+        #   [Reek::SmellDetectors::Attribute,
+        #    Reek::SmellDetectors::BooleanParameter,
+        #    Reek::SmellDetectors::ClassVariable,
         #    ...]
         #
         def descendants
@@ -122,6 +124,24 @@ module Reek
           descendants.map { |descendant| descendant.to_s.split('::').last }.
             include?(detector)
         end
+
+        #
+        # Transform a detector name to the corresponding constant.
+        # Note that we assume a valid name - exceptions are not handled here.
+        #
+        # @param detector_name [String] the detector in question, e.g. 'DuplicateMethodCall'
+        # @return [SmellDetector] - this will return the class, not an instance
+        #
+        def to_detector(detector_name)
+          SmellDetectors.const_get detector_name
+        end
+
+        #
+        # @return [Set<Symbol>] - all configuration keys that are available for this detector
+        #
+        def configuration_keys
+          Set.new(default_config.keys.map(&:to_sym))
+        end
       end
     end
   end

data/lib/reek/smell_detectors/boolean_parameter.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require_relative 'base_detector'
-require_relative 'smell_warning'
 
 module Reek
   module SmellDetectors

data/lib/reek/smell_detectors/class_variable.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'set'
 require_relative 'base_detector'
-require_relative 'smell_warning'
 
 module Reek
   module SmellDetectors