reek 5.0.2 → 5.1.0

data/lib/reek/code_comment.rb

@@ -122,6 +122,7 @@ module Reek
 
       def escalate_bad_detector
         return if SmellDetectors::BaseDetector.valid_detector?(detector_name)
+
         raise Errors::BadDetectorInCommentError, detector_name: detector_name,
                                                  original_comment: original_comment,
                                                  source: source,
@@ -142,6 +143,7 @@ module Reek
         @detector_class = SmellDetectors::BaseDetector.to_detector(detector_name)
 
         return if given_keys_legit?
+
         raise Errors::BadDetectorConfigurationKeyInCommentError, detector_name: detector_name,
                                                                  offensive_keys: configuration_keys_difference,
                                                                  original_comment: original_comment,

data/lib/reek/configuration/app_configuration.rb

@@ -15,9 +15,6 @@ module Reek
     # @public
     class AppConfiguration
       include ConfigurationValidator
-      EXCLUDE_PATHS_KEY = 'exclude_paths'
-      DIRECTORIES_KEY = 'directories'
-      DETECTORS_KEY = 'detectors'
 
       # Instantiate a configuration via the given path.
       #

data/lib/reek/configuration/configuration_converter.rb

@@ -71,9 +71,9 @@ module Reek
       # @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]
+        return unless configuration[DETECTORS_KEY]
 
-        configuration[AppConfiguration::DETECTORS_KEY].tap do |detectors|
+        configuration[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|
@@ -91,9 +91,9 @@ module Reek
       # @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]
+        return unless configuration[DIRECTORIES_KEY]
 
-        configuration[AppConfiguration::DIRECTORIES_KEY].tap do |directories|
+        configuration[DIRECTORIES_KEY].tap do |directories|
           directories.keys.each do |directory|
             directories[directory].each do |detector, configuration|
               convertible_attributes(configuration).each do |attribute|

data/lib/reek/configuration/directory_directives.rb

@@ -17,6 +17,7 @@ module Reek
       # @return [Hash | nil] the configuration for the source or nil
       def directive_for(source_via)
         return unless source_via
+
         source_base_dir = Pathname.new(source_via).dirname
         hit = best_match_for source_base_dir
         self[hit]

data/lib/reek/configuration/schema_validator.rb

@@ -24,6 +24,7 @@ module Reek
       def validate
         errors = CLI::Silencer.without_warnings { @validator.validate @configuration }
         return if !errors || errors.empty?
+
         raise Errors::ConfigFileError, error_message(errors)
       end
 

data/lib/reek/context/method_context.rb

@@ -81,6 +81,7 @@ module Reek
         own = super
         return own unless own.empty?
         return parent_exp.full_comment if parent_exp
+
         ''
       end
 

data/lib/reek/context/module_context.rb

@@ -26,7 +26,7 @@ module Reek
       #
       # @param child [CodeContext] the child context to register
       def append_child_context(child)
-        visibility_tracker.set_child_visibility(child)
+        visibility_tracker.apply_visibility(child)
         super
       end
 
@@ -44,9 +44,9 @@ module Reek
       end
 
       def defined_instance_methods(visibility: :any)
-        instance_method_children.select do |context|
-          visibility == :any || context.visibility == visibility
-        end
+        return instance_method_children if visibility == :any
+
+        instance_method_children.select { |child| child.visibility == visibility }
       end
 
       def instance_method_calls
@@ -76,6 +76,7 @@ module Reek
       # @quality :reek:FeatureEnvy
       def namespace_module?
         return false if exp.type == :casgn
+
         children = exp.direct_children
         children.any? && children.all? { |child| [:casgn, :class, :module].include? child.type }
       end

data/lib/reek/context/visibility_tracker.rb

@@ -22,6 +22,7 @@ module Reek
       #
       def track_visibility(children:, visibility:, names:)
         return unless VISIBILITY_MODIFIERS.include? visibility
+
         if names.any?
           children.each do |child|
             child.visibility = visibility if names.include?(child.name)
@@ -44,17 +45,19 @@ module Reek
       #
       def track_singleton_visibility(children:, visibility:, names:)
         return if names.empty?
+
         visibility = VISIBILITY_MAP[visibility]
         return unless visibility
+
         track_visibility children: children, visibility: visibility, names: names
       end
 
-      # Sets the visibility of a child CodeContext to the tracked visibility.
+      # Sets the visibility of a CodeContext to the tracked visibility.
       #
-      # @param child [CodeContext]
+      # @param context [CodeContext]
       #
-      def set_child_visibility(child)
-        child.apply_current_visibility tracked_visibility
+      def apply_visibility(context)
+        context.apply_current_visibility tracked_visibility
       end
 
       private

data/lib/reek/context_builder.rb

@@ -521,6 +521,7 @@ module Reek
 
     def register_attributes(exp)
       return unless exp.attribute_writer?
+
       klass = current_context.attribute_context_class
       exp.args.each do |arg|
         append_new_context(klass, arg, exp)

data/lib/reek/detector_repository.rb

@@ -26,6 +26,7 @@ module Reek
     #         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

data/lib/reek/errors/incomprehensible_source_error.rb

@@ -17,8 +17,8 @@ module Reek
         It would be great if you could report this back to the Reek team by opening 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.
+        Please make sure to include the source in question, the Reek version,
+        and this entire error message, including the original exception below.
 
         Exception message:
 

data/lib/reek/errors/syntax_error.rb

@@ -15,6 +15,10 @@ module Reek
         This is a problem that is outside of Reek's scope and should be fixed by you, the
         user, in order for Reek being able to continue.
 
+        Things you can try:
+        - Check the syntax of the problematic file
+        - If the file is not in fact a Ruby file, exclude it in your .reek.yml file
+
         Exception message:
 
         %<exception>s

data/lib/reek/examiner.rb

@@ -95,6 +95,7 @@ module Reek
       end
     rescue StandardError => exception
       raise unless @error_handler.handle exception
+
       []
     end
 

data/lib/reek/report/text_report.rb

@@ -43,6 +43,7 @@ module Reek
 
       def display_total_smell_count
         return unless examiners.size > 1
+
         print total_smell_count_message
       end
 

data/lib/reek/smell_detectors/control_parameter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'base_detector'
+require_relative 'control_parameter_helpers/candidate'
+require_relative 'control_parameter_helpers/control_parameter_finder'
 
 module Reek
   module SmellDetectors
@@ -61,125 +63,29 @@ module Reek
 
       private
 
+      #
+      # @return [Array<ControlParameterHelpers::Candidate>]
+      #
       def control_parameters
         potential_parameters.
-          map { |param| FoundControlParameter.new(param, find_matches(param)) }.
+          map { |parameter| ControlParameterHelpers::Candidate.new(parameter, find_matches(parameter)) }.
           select(&:smells?)
       end
 
+      #
+      # @return [Array<Symbol>] e.g. [:bravo, :charlie]
+      #
       def potential_parameters
         expression.parameter_names
       end
 
-      def find_matches(param)
-        ControlParameterFinder.new(expression, param).find_matches
-      end
-
       #
-      # Collects information about a single control parameter.
+      # @param parameter [Symbol] the name of the parameter
+      # @return [Array<Reek::AST::Node>]
       #
-      class FoundControlParameter
-        def initialize(param, occurences)
-          @param = param
-          @occurences = occurences
-        end
-
-        def smells?
-          occurences.any?
-        end
-
-        def lines
-          occurences.map(&:line)
-        end
-
-        def name
-          param.to_s
-        end
-
-        private
-
-        attr_reader :occurences, :param
+      def find_matches(parameter)
+        ControlParameterHelpers::ControlParameterFinder.new(expression, parameter).find_matches
       end
-
-      private_constant :FoundControlParameter
-
-      # Finds cases of ControlParameter in a particular node for a particular parameter
-      class ControlParameterFinder
-        CONDITIONAL_NODE_TYPES = [:if, :case, :and, :or].freeze
-
-        def initialize(node, param)
-          @node = node
-          @param = param
-        end
-
-        def find_matches
-          return [] if legitimite_uses?
-          nested_finders.flat_map(&:find_matches) + uses_of_param_in_condition
-        end
-
-        def legitimite_uses?
-          return true if uses_param_in_body?
-          return true if uses_param_in_call_in_condition?
-          return true if nested_finders.any?(&:legitimite_uses?)
-          false
-        end
-
-        private
-
-        attr_reader :node, :param
-
-        def conditional_nodes
-          node.body_nodes(CONDITIONAL_NODE_TYPES)
-        end
-
-        def nested_finders
-          @nested_finders ||= conditional_nodes.flat_map do |node|
-            self.class.new(node, param)
-          end
-        end
-
-        def uses_param_in_call_in_condition?
-          return unless condition
-          condition.each_node(:send) do |inner|
-            next unless regular_call_involving_param? inner
-            return true
-          end
-          false
-        end
-
-        def uses_of_param_in_condition
-          return [] unless condition
-          condition.each_node(:lvar).select { |inner| inner.var_name == param }
-        end
-
-        def condition
-          return nil unless CONDITIONAL_NODE_TYPES.include? node.type
-          node.condition
-        end
-
-        def regular_call_involving_param?(call_node)
-          call_involving_param?(call_node) && !comparison_call?(call_node)
-        end
-
-        def comparison_call?(call_node)
-          comparison_method_names.include? call_node.name
-        end
-
-        def comparison_method_names
-          [:==, :!=, :=~]
-        end
-
-        def call_involving_param?(call_node)
-          call_node.each_node(:lvar).any? { |it| it.var_name == param }
-        end
-
-        def uses_param_in_body?
-          nodes = node.body_nodes([:lvar], CONDITIONAL_NODE_TYPES)
-          nodes.any? { |lvar_node| lvar_node.var_name == param }
-        end
-      end
-
-      private_constant :ControlParameterFinder
     end
   end
 end

data/lib/reek/smell_detectors/control_parameter_helpers/call_in_condition_finder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Reek
+  module SmellDetectors
+    module ControlParameterHelpers
+      #
+      # CallInConditionFinder finds usages of the given parameter
+      # in the context of a method call in a condition, e.g.:
+      #
+      # def alfa(bravo)
+      #   if charlie(bravo)
+      #     delta
+      #   end
+      # end
+      #
+      # or
+      #
+      # def alfa(bravo)
+      #   if bravo.charlie?
+      #     delta
+      #   end
+      # end
+      #
+      # Those usages are legit and should not trigger the ControlParameter smell warning.
+      #
+      class CallInConditionFinder
+        COMPARISON_METHOD_NAMES = [:==, :!=, :=~].freeze
+
+        #
+        # @param node [Reek::AST::Node] the node in our current scope,
+        #   e.g. s(:def, :alfa,
+        #          s(:args,
+        #            s(:arg, :bravo),
+        # @param parameter [Symbol] the parameter name in question
+        #   e.g. in the example above this would be :bravo
+        #
+        def initialize(node, parameter)
+          @node = node
+          @parameter = parameter
+        end
+
+        #
+        # @return [Boolean] if the parameter in question has been used in the context of a
+        #   method call in a condition
+        #
+        def uses_param_in_call_in_condition?
+          condition = node.condition
+          return false unless condition
+
+          condition.each_node(:send) do |inner|
+            return true if regular_call_involving_param?(inner)
+          end
+          false
+        end
+
+        private
+
+        attr_reader :node, :parameter
+
+        #
+        # @return [Boolean] if the parameter is used in a method call that is not a comparison call
+        #   e.g. this would return true given that "bravo" is the parameter in question:
+        #
+        #     if charlie(bravo) then delta end
+        #
+        #   while this would return false (since its a comparison):
+        #
+        #     if bravo == charlie then charlie end
+        #
+        def regular_call_involving_param?(call_node)
+          call_involving_param?(call_node) && !comparison_call?(call_node)
+        end
+
+        #
+        # @return [Boolean] if the parameter is used in the given method call
+        #
+        def call_involving_param?(call_node)
+          call_node.each_node(:lvar).any? { |it| it.var_name == parameter }
+        end
+
+        #
+        # @return [Boolean] if the given method call is a comparison call
+        #
+        # :reek:UtilityFunction
+        def comparison_call?(call_node)
+          COMPARISON_METHOD_NAMES.include? call_node.name
+        end
+      end
+    end
+  end
+end

data/lib/reek/smell_detectors/control_parameter_helpers/candidate.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Reek
+  module SmellDetectors
+    module ControlParameterHelpers
+      #
+      # Collects information about a single control parameter.
+      #
+      class Candidate
+        #
+        # @param parameter [Symbol] the parameter name
+        # @param occurences [Array<Reek::AST::Node>] the occurences of the ControlParameter smell
+        #   e.g. [s(:lvar, :bravo), s(:lvar, :bravo)]
+        #
+        def initialize(parameter, occurences)
+          @parameter = parameter
+          @occurences = occurences
+        end
+
+        def smells?
+          occurences.any?
+        end
+
+        def lines
+          occurences.map(&:line)
+        end
+
+        def name
+          parameter.to_s
+        end
+
+        private
+
+        attr_reader :occurences, :parameter
+      end
+    end
+  end
+end