reek 4.8.1 → 5.0.2

data/lib/reek/configuration/configuration_converter.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative './configuration_validator'
+
+module Reek
+  module Configuration
+    # Responsible for converting marked strings coming from the outside world
+    # into proper regexes.
+    class ConfigurationConverter
+      REGEXABLE_ATTRIBUTES = %w(accept reject exclude).freeze
+      include ConfigurationValidator
+      attr_reader :configuration
+
+      # @param configuration [Hash] e.g.
+      #
+      #   detectors => {
+      #     "UnusedPrivateMethod" => {"exclude"=>["/exclude regexp/"]},
+      #     "UncommunicativeMethodName"=>{"reject"=>["reject name"], "accept"=>["accept name"]
+      #   },
+      #   directories => {
+      #     "app/controllers" => {
+      #       "UnusedPrivateMethod" => {"exclude"=>["/exclude regexp/"]},
+      #       "UncommunicativeMethodName"=>{"reject"=>["reject name"], "accept"=>["accept name"]}
+      #     }
+      #   }
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      # Converts all marked strings across the whole configuration to regexes.
+      # @return [Hash]
+      #
+      def convert
+        strings_to_regexes_for_detectors
+        strings_to_regexes_for_directories
+
+        configuration
+      end
+
+      private
+
+      # @param value [String] String that is potentially marked as regex, e.g. "/foobar/".
+      # @return [Bool] if the string in question is marked as regex.
+      #
+      # @quality :reek:UtilityFunction
+      def marked_as_regex?(value)
+        value.start_with?('/') && value.end_with?('/')
+      end
+
+      # @param value [value] String that is potentially marked as regex, e.g. "/foobar/".
+      # @return [Regexp] e.g. /foobar/.
+      #
+      def to_regex(value)
+        marked_as_regex?(value) ? Regexp.new(value[1..-2]) : value
+      end
+
+      # @param detector_configuration [Hash] e.g.
+      #   { "UnusedPrivateMethod" => {"exclude"=>["/exclude regexp/"] }
+      # @return [Array] all the attributes from the detector configuration that potentially contain regexes.
+      #   Using this example above this would just be "exclude".
+      #
+      # @quality :reek:UtilityFunction
+      def convertible_attributes(detector_configuration)
+        detector_configuration.keys & REGEXABLE_ATTRIBUTES
+      end
+
+      # Iterates over our detector configuration and converts all marked strings into regexes.
+      # @return nil
+      #
+      # @quality :reek:DuplicateMethodCall { max_calls: 3 }
+      # @quality :reek:NestedIterators { max_allowed_nesting: 3 }
+      # @quality :reek:TooManyStatements { max_statements: 6 }
+      def strings_to_regexes_for_detectors
+        return unless configuration[AppConfiguration::DETECTORS_KEY]
+
+        configuration[AppConfiguration::DETECTORS_KEY].tap do |detectors|
+          detectors.keys.each do |detector|
+            convertible_attributes(detectors[detector]).each do |attribute|
+              detectors[detector][attribute] = detectors[detector][attribute].map do |item|
+                to_regex item
+              end
+            end
+          end
+        end
+      end
+
+      # Iterates over our directory configuration and converts all marked strings into regexes.
+      # @return nil
+      #
+      # @quality :reek:DuplicateMethodCall { max_calls: 3 }
+      # @quality :reek:NestedIterators { max_allowed_nesting: 4 }
+      # @quality :reek:TooManyStatements { max_statements: 7 }
+      def strings_to_regexes_for_directories
+        return unless configuration[AppConfiguration::DIRECTORIES_KEY]
+
+        configuration[AppConfiguration::DIRECTORIES_KEY].tap do |directories|
+          directories.keys.each do |directory|
+            directories[directory].each do |detector, configuration|
+              convertible_attributes(configuration).each do |attribute|
+                directories[directory][detector][attribute] = directories[directory][detector][attribute].map do |item|
+                  to_regex item
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reek/configuration/configuration_file_finder.rb

@@ -1,35 +1,28 @@
 # frozen_string_literal: true
 
 require 'pathname'
+require_relative './configuration_converter'
+require_relative './schema_validator'
+require_relative '../errors/config_file_error'
 
 module Reek
   module Configuration
-    # Raised when config file is not properly readable.
-    class ConfigFileException < StandardError; end
     #
     # ConfigurationFileFinder is responsible for finding Reek's configuration.
     #
     # There are 3 ways of passing `reek` a configuration file:
     # 1. Using the cli "-c" switch
-    # 2. Having a file ending with .reek either in your current working
+    # 2. Having a file .reek.yml either in your current working
     #    directory or in a parent directory
-    # 3. Having a file ending with .reek in your HOME directory
+    # 3. Having a file .reek.yml in your HOME directory
     #
     # The order in which ConfigurationFileFinder tries to find such a
     # configuration file is exactly like above.
     module ConfigurationFileFinder
-      TOO_MANY_CONFIGURATION_FILES_MESSAGE = <<-MESSAGE.freeze
-
-        Error: Found multiple configuration files %<files>s
-        while scanning directory %<directory>s.
-
-        Reek supports only one configuration file. You have 2 options now:
-        1) Remove all offending files.
-        2) Be specific about which one you want to load via the -c switch.
-
-      MESSAGE
+      DEFAULT_FILE_NAME = '.reek.yml'
 
       class << self
+        include ConfigurationValidator
         #
         # Finds and loads a configuration file from a given path.
         #
@@ -47,7 +40,7 @@ module Reek
         #
         # @return [File|nil]
         #
-        # :reek:ControlParameter
+        # @quality :reek:ControlParameter
         def find(path: nil, current: Pathname.pwd, home: Pathname.new(Dir.home))
           path || find_by_dir(current) || find_in_dir(home)
         end
@@ -59,19 +52,18 @@ module Reek
         # @param path [String]
         # @return [Hash]
         #
-        # :reek:TooManyStatements: { max_statements: 6 }
+        # @quality :reek:TooManyStatements { max_statements: 6 }
         def load_from_file(path)
           return {} unless path
+
           begin
             configuration = YAML.load_file(path) || {}
           rescue StandardError => error
-            raise ConfigFileException, "Invalid configuration file #{path}, error is #{error}"
+            raise Errors::ConfigFileError, "Invalid configuration file #{path}, error is #{error}"
           end
 
-          unless configuration.is_a? Hash
-            raise ConfigFileException, "Invalid configuration file \"#{path}\" -- Not a hash"
-          end
-          configuration
+          SchemaValidator.new(configuration).validate
+          ConfigurationConverter.new(configuration).convert
         end
 
         private
@@ -90,29 +82,12 @@ module Reek
 
         #
         # Checks a given directory for a configuration file and returns it.
-        # Raises an exception if we find more than one.
         #
         # @return [File|nil]
         #
-        # :reek:FeatureEnvy
+        # @quality :reek:FeatureEnvy
         def find_in_dir(dir)
-          found = dir.children.select { |item| item.file? && item.to_s.end_with?('.reek') }.sort
-          if found.size > 1
-            escalate_too_many_configuration_files found, dir
-          else
-            found.first
-          end
-        end
-
-        #
-        # Writes a proper warning message to STDERR and then exits the program.
-        #
-        # @return [undefined]
-        #
-        def escalate_too_many_configuration_files(found, directory)
-          offensive_files = found.map { |file| "'#{file.basename}'" }.join(', ')
-          warn format(TOO_MANY_CONFIGURATION_FILES_MESSAGE, files: offensive_files, directory: directory)
-          exit 1
+          dir.children.detect { |item| item.file? && item.basename.to_s == DEFAULT_FILE_NAME }
         end
       end
     end

data/lib/reek/configuration/configuration_validator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../errors/config_file_error'
+
 module Reek
   module Configuration
     #
@@ -8,37 +10,24 @@ module Reek
     module ConfigurationValidator
       private
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def smell_type?(key)
-        case key
-        when Class
-          true
-        when String
-          begin
-            Reek::SmellDetectors.const_defined? key
-          rescue NameError
-            false
-          end
-        end
+        Reek::SmellDetectors.const_defined? key
+      rescue NameError
+        false
       end
 
-      # :reek:UtilityFunction
+      # @quality :reek:UtilityFunction
       def key_to_smell_detector(key)
-        case key
-        when Class
-          key
-        else
-          Reek::SmellDetectors.const_get key
-        end
-      end
-
-      def error_message_for_file_given(pathname)
-        "Configuration error: `#{pathname}` is supposed to be a directory but is a file"
+        Reek::SmellDetectors.const_get key
       end
 
       def with_valid_directory(path)
         directory = Pathname.new path.to_s.chomp('/')
-        abort(error_message_for_file_given(directory)) if directory.file?
+        if directory.file?
+          raise Errors::ConfigFileError,
+                "`#{directory}` is supposed to be a directory but is a file"
+        end
         yield directory if block_given?
       end
     end

data/lib/reek/configuration/default_directive.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative './configuration_validator'
+
 module Reek
   module Configuration
     #
@@ -8,9 +10,21 @@ module Reek
     module DefaultDirective
       include ConfigurationValidator
 
-      def add(key, config)
-        detector = key_to_smell_detector(key)
-        self[detector] = (self[detector] || {}).merge config
+      # Adds the configuration for detectors as default directive.
+      #
+      # @param detectors_configuration [Hash] the configuration e.g.:
+      #   {
+      #    :IrresponsibleModule => {:enabled=>false},
+      #    :Attribute => {:enabled=>true}
+      #   }
+      #
+      # @return [self]
+      def add(detectors_configuration)
+        detectors_configuration.each do |name, configuration|
+          detector = key_to_smell_detector(name)
+          self[detector] = (self[detector] || {}).merge configuration
+        end
+        self
       end
     end
   end

data/lib/reek/configuration/directory_directives.rb

@@ -24,17 +24,23 @@ module Reek
 
       # Adds a directive and returns self.
       #
-      # @param path [Pathname] the path
-      # @param config [Hash] the configuration
+      # @param directory_config [Hash] the configuration e.g.:
+      #   {
+      #    "samples/two_smelly_files" => {:IrresponsibleModule=>{:enabled=>false}},
+      #    "samples/three_clean_files" => {:Attribute=>{:enabled=>true}}
+      #   }
       #
       # @return [self]
       #
-      # :reek:NestedIterators: { max_allowed_nesting: 2 }
-      def add(path, config)
-        with_valid_directory(path) do |directory|
-          self[directory] = config.each_with_object({}) do |(key, value), hash|
-            abort(error_message_for_invalid_smell_type(key)) unless smell_type?(key)
-            hash[key_to_smell_detector(key)] = value
+      # @quality :reek:NestedIterators { max_allowed_nesting: 3 }
+      # @quality :reek:TooManyStatements { max_statements: 6 }
+      def add(directory_config)
+        directory_config.each do |path, detector_config|
+          with_valid_directory(path) do |directory|
+            self[directory] = detector_config.each_with_object({}) do |(key, value), hash|
+              abort(error_message_for_invalid_smell_type(key)) unless smell_type?(key)
+              hash[key_to_smell_detector(key)] = value
+            end
           end
         end
         self
@@ -42,8 +48,8 @@ module Reek
 
       private
 
-      # :reek:DuplicateMethodCall: { max_calls: 2 }
-      # :reek:FeatureEnvy
+      # @quality :reek:DuplicateMethodCall { max_calls: 2 }
+      # @quality :reek:FeatureEnvy
       def best_match_for(source_base_dir)
         keys.
           select { |pathname| source_base_dir.to_s.match(/#{Regexp.escape(pathname.to_s)}/) }.
@@ -52,7 +58,7 @@ module Reek
 
       def error_message_for_invalid_smell_type(klass)
         "You are trying to configure smell type #{klass} but we can't find one with that name.\n" \
-          "Please make sure you spelled it right. (See 'defaults.reek' in the Reek\n" \
+          "Please make sure you spelled it right. (See 'docs/defaults.reek' in the Reek\n" \
           'repository for a list of all available smell types.)'
       end
     end

data/lib/reek/configuration/excluded_paths.rb

@@ -10,7 +10,7 @@ module Reek
     module ExcludedPaths
       include ConfigurationValidator
 
-      # :reek:NestedIterators: { max_allowed_nesting: 2 }
+      # @quality :reek:NestedIterators { max_allowed_nesting: 2 }
       def add(paths)
         paths.each do |path|
           with_valid_directory(path) { |directory| self << directory }

data/lib/reek/configuration/rake_task_converter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Reek
+  module Configuration
+    # Responsible for converting configuration values coming from the outside world
+    # to whatever we want to use internally.
+    module RakeTaskConverter
+      class << self
+        REGEXABLE_ATTRIBUTES = %w(accept reject exclude).freeze
+
+        # Converts marked strings like "/foobar/" into regexes.
+        #
+        # @param configuration [Hash] e.g.
+        #   {"enabled"=>true, "exclude"=>[], "reject"=>[/^[a-z]$/, /[0-9]$/, /[A-Z]/], "accept"=>[]}
+        # @return [Hash]
+        #
+        # @quality :reek:NestedIterators { max_allowed_nesting: 2 }
+        def convert(configuration)
+          (configuration.keys & REGEXABLE_ATTRIBUTES).each do |attribute|
+            configuration[attribute] = configuration[attribute].map do |item|
+              item.is_a?(Regexp) ? item.inspect : item
+            end
+          end
+          configuration
+        end
+      end
+    end
+  end
+end

data/lib/reek/configuration/schema.yml

@@ -0,0 +1,210 @@
+---
+type: map
+mapping:
+  "detectors":
+    type: map
+    mapping: &all_detectors
+      Attribute:
+        type: map
+        mapping: &detector_base
+          "enabled":
+            type: bool
+          "exclude":
+            type: seq
+            sequence:
+              - type: str
+      BooleanParameter:
+        type: map
+        mapping:
+          <<: *detector_base
+      ClassVariable:
+        type: map
+        mapping:
+          <<: *detector_base
+      ControlParameter:
+        type: map
+        mapping:
+          <<: *detector_base
+      DataClump:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_copies:
+            type: number
+          min_clump_size:
+            type: number
+      DuplicateMethodCall:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_calls:
+            type: number
+          allow_calls:
+            type: seq
+            sequence:
+              - type: str
+      FeatureEnvy:
+        type: map
+        mapping:
+          <<: *detector_base
+      InstanceVariableAssumption:
+        type: map
+        mapping:
+          <<: *detector_base
+      IrresponsibleModule:
+        type: map
+        mapping:
+          <<: *detector_base
+      LongParameterList:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_params:
+            type: number
+          overrides:
+            type: map
+            mapping:
+              initialize:
+                type: map
+                mapping:
+                  max_params:
+                    type: number
+      LongYieldList:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_params:
+            type: number
+      ManualDispatch:
+        type: map
+        mapping:
+          <<: *detector_base
+      MissingSafeMethod:
+        type: map
+        mapping:
+          <<: *detector_base
+      ModuleInitialize:
+        type: map
+        mapping:
+          <<: *detector_base
+      NestedIterators:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_allowed_nesting:
+            type: number
+          ignore_iterators:
+            type: seq
+            sequence:
+              - type: str
+      NilCheck:
+        type: map
+        mapping:
+          <<: *detector_base
+      RepeatedConditional:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_ifs:
+            type: number
+      SubclassedFromCoreClass:
+        type: map
+        mapping:
+          <<: *detector_base
+      Syntax:
+        type: map
+        mapping:
+          <<: *detector_base
+      TooManyConstants:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_constants:
+            type: number
+      TooManyInstanceVariables:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_instance_variables:
+            type: number
+      TooManyMethods:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_methods:
+            type: number
+      TooManyStatements:
+        type: map
+        mapping:
+          <<: *detector_base
+          max_statements:
+            type: number
+      UncommunicativeMethodName:
+        type: map
+        mapping:
+          <<: *detector_base
+          reject: &reject_settings
+            type: seq
+            sequence:
+              - type: str
+          accept: &accept_settings
+            type: seq
+            sequence:
+              - type: str
+      UncommunicativeModuleName:
+        type: map
+        mapping:
+          <<: *detector_base
+          reject: *reject_settings
+          accept: *accept_settings
+      UncommunicativeParameterName:
+        type: map
+        mapping:
+          <<: *detector_base
+          reject: *reject_settings
+          accept: *accept_settings
+      UncommunicativeVariableName:
+        type: map
+        mapping:
+          <<: *detector_base
+          reject: *reject_settings
+          accept: *accept_settings
+      UnusedParameters:
+        type: map
+        mapping:
+          <<: *detector_base
+      UnusedPrivateMethod:
+        type: map
+        mapping:
+          <<: *detector_base
+      UtilityFunction:
+        type: map
+        mapping:
+          <<: *detector_base
+          public_methods_only:
+            type: bool
+
+  "directories":
+    type: map
+    mapping:
+      # For any given key that is not matched somewhere else we'll apply the schema below.
+      # So this will just slurp in every directory we throw at it and then validate everything under
+      # it against all detectors - for instance:
+      #
+      #  directories:
+      #    "web_app/app/controllers":
+      #      NestedIterators:
+      #        enabled: false
+      #    "web_app/app/helpers":
+      #      UtilityFunction:
+      #        enabled: false
+      #
+      # For details check out: http://www.kuwata-lab.com/kwalify/ruby/users-guide.02.html#tips-default
+      =:
+        type: map
+        mapping: *all_detectors
+        
+  "exclude_paths":
+    type: seq
+    sequence:
+      - type: str

data/lib/reek/configuration/schema_validator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative '../cli/silencer'
+Reek::CLI::Silencer.without_warnings { require 'kwalify' }
+require_relative '../errors/config_file_error'
+
+module Reek
+  module Configuration
+    #
+    # Schema validator module.
+    #
+    class SchemaValidator
+      SCHEMA_FILE_PATH = File.expand_path('./schema.yml', __dir__)
+
+      def initialize(configuration)
+        @configuration = configuration
+        @validator = CLI::Silencer.without_warnings do
+          schema_file = Kwalify::Yaml.load_file(SCHEMA_FILE_PATH)
+          Kwalify::Validator.new(schema_file)
+        end
+      end
+
+      def validate
+        errors = CLI::Silencer.without_warnings { @validator.validate @configuration }
+        return if !errors || errors.empty?
+        raise Errors::ConfigFileError, error_message(errors)
+      end
+
+      private
+
+      # :reek:UtilityFunction
+      def error_message(errors)
+        "We found some problems with your configuration file: #{CLI::Silencer.silently { errors.join(', ') }}"
+      end
+    end
+  end
+end

data/lib/reek/context/attribute_context.rb

@@ -7,7 +7,7 @@ module Reek
     #
     # A context wrapper for attribute definitions found in a syntax tree.
     #
-    # :reek:Attribute
+    # @quality :reek:Attribute
     class AttributeContext < CodeContext
       attr_accessor :visibility
 

data/lib/reek/context/code_context.rb

@@ -14,8 +14,8 @@ module Reek
     # code element. CodeContexts form a tree in the same way the code does,
     # with each context holding a reference to a unique outer context.
     #
-    # :reek:TooManyMethods: { max_methods: 19 }
-    # :reek:TooManyInstanceVariables: { max_instance_variables: 8 }
+    # @quality :reek:TooManyMethods { max_methods: 19 }
+    # @quality :reek:TooManyInstanceVariables { max_instance_variables: 8 }
     class CodeContext
       include Enumerable
       extend Forwardable
@@ -110,8 +110,8 @@ module Reek
         self
       end
 
-      # :reek:TooManyStatements: { max_statements: 6 }
-      # :reek:FeatureEnvy
+      # @quality :reek:TooManyStatements { max_statements: 6 }
+      # @quality :reek:FeatureEnvy
       def record_call_to(exp)
         receiver = exp.receiver
         type = receiver ? receiver.type : :self