reek 4.7.1 → 5.0.0

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,14 +7,14 @@ module Reek
     #
     # A context wrapper for attribute definitions found in a syntax tree.
     #
-    # :reek:Attribute
+    # @quality :reek:Attribute
     class AttributeContext < CodeContext
       attr_accessor :visibility
 
-      def initialize(context, exp, send_expression)
+      def initialize(exp, send_expression)
         @visibility = :public
         @send_expression = send_expression
-        super context, exp
+        super exp
       end
 
       def full_comment

data/lib/reek/context/code_context.rb

@@ -14,51 +14,19 @@ 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
-      delegate each_node: :exp
       delegate [:name, :type] => :exp
 
       attr_reader :children, :parent, :exp, :statement_counter
 
       # Initializes a new CodeContext.
       #
-      # @param _parent [CodeContext, nil] The parent context
       # @param exp [Reek::AST::Node] The code described by this context
-      #
-      # For example, given the following code:
-      #
-      #   class Omg
-      #     def foo(x)
-      #       puts x
-      #     end
-      #   end
-      #
-      # The {ContextBuilder} object first instantiates a {RootContext}, which has no parent.
-      #
-      # Next, it instantiates a {ModuleContext}, with +parent+ being the
-      # {RootContext} just created, and +exp+ looking like this:
-      #
-      #  (class
-      #    (const nil :Omg) nil
-      #    (def :foo
-      #      (args
-      #        (arg :x))
-      #      (send nil :puts
-      #        (lvar :x))))
-      #
-      # Finally, {ContextBuilder} will instantiate a {MethodContext}. This time,
-      # +parent+ is the {ModuleContext} created above, and +exp+ is:
-      #
-      #   (def :foo
-      #     (args
-      #       (arg :x))
-      #     (send nil :puts
-      #       (lvar :x)))
-      def initialize(_parent, exp)
+      def initialize(exp)
         @exp                = exp
         @children           = []
         @statement_counter  = StatementCounter.new
@@ -71,12 +39,12 @@ module Reek
       # @yield block that is executed for every node.
       #
       def local_nodes(type, ignored = [], &blk)
-        ignored += [:casgn, :class, :module]
-        each_node(type, ignored, &blk)
+        ignored |= [:class, :module]
+        exp.each_node(type, ignored, &blk)
       end
 
       # Iterate over `self` and child contexts.
-      # The main difference (among others) to `each_node` is that we are traversing
+      # The main difference (among others) to `local_nodes` is that we are traversing
       # `CodeContexts` here, not AST nodes (see `Reek::AST::Node`).
       #
       # @yield block that is executed for every node.
@@ -91,6 +59,44 @@ module Reek
         end
       end
 
+      # Link the present context to its parent.
+      #
+      # @param parent [Reek::AST::Node] The parent context of the code described by this context
+      #
+      # For example, given the following code:
+      #
+      #   class Omg
+      #     def foo(x)
+      #       puts x
+      #     end
+      #   end
+      #
+      # The {ContextBuilder} object first instantiates a {RootContext}, which has no parent.
+      #
+      # Next, it instantiates a {ModuleContext}, with +exp+ looking like this:
+      #
+      #  (class
+      #    (const nil :Omg) nil
+      #    (def :foo
+      #      (args
+      #        (arg :x))
+      #      (send nil :puts
+      #        (lvar :x))))
+      #
+      # It will then call #register_with_parent on the {ModuleContext}, passing
+      # in the parent {RootContext}.
+      #
+      # Finally, {ContextBuilder} will instantiate a {MethodContext}. This time,
+      # +exp+ is:
+      #
+      #   (def :foo
+      #     (args
+      #       (arg :x))
+      #     (send nil :puts
+      #       (lvar :x)))
+      #
+      # Then it will call #register_with_parent on the {MethodContext}, passing
+      # in the parent {ModuleContext}.
       def register_with_parent(parent)
         @parent = parent.append_child_context(self) if parent
       end
@@ -104,17 +110,15 @@ 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
         line = exp.line
         case type
         when :lvar, :lvasgn
-          unless exp.object_creation_call?
-            refs.record_reference(name: receiver.name, line: line)
-          end
+          refs.record_reference(name: receiver.name, line: line) unless exp.object_creation_call?
         when :self
           refs.record_reference(name: :self, line: line)
         end

data/lib/reek/context/ghost_context.rb

@@ -41,8 +41,6 @@ module Reek
                                             names: names
       end
 
-      def track_singleton_visibility(_visibility, _names); end
-
       def record_use_of_self
         parent.record_use_of_self
       end

data/lib/reek/context/method_context.rb

@@ -7,14 +7,15 @@ module Reek
     #
     # A context wrapper for any method definition found in a syntax tree.
     #
-    # :reek:Attribute
+    # @quality :reek:Attribute
     class MethodContext < CodeContext
       attr_accessor :visibility
       attr_reader :refs
 
-      def initialize(context, exp)
+      def initialize(exp, parent_exp)
+        @parent_exp = parent_exp
         @visibility = :public
-        super
+        super exp
       end
 
       def references_self?
@@ -22,29 +23,24 @@ module Reek
       end
 
       def uses_param?(param)
-        # local_nodes(:lvasgn) catches:
+        # :lvasgn catches:
+        #
         #   def foo(bar); bar += 1; end
-        # In this example there is no `lvar` node present.
         #
-        # local_nodes(:lvar) catches:
+        # :lvar catches:
+        #
         #   def foo(bar); other(bar); end
         #   def foo(bar); tmp = other(bar); tmp[0]; end
         #
-        # Note that in the last example the `lvar` node for `bar` is part of an `lvasgn` node for `tmp`.
-        # This means that if we would just search for [:lvar, :lvasgn]
-        # (e.g. via Reek::AST::Node#find_nodes) this would fail for this example since we would
-        # stop at the `lvasgn` and not detect the contained `lvar`.
-        # Hence we first get all `lvar` nodes followed by all `lvasgn` nodes.
-        #
-        (local_nodes(:lvar) + local_nodes(:lvasgn)).find { |node| node.var_name == param.to_sym }
+        local_nodes([:lvar, :lvasgn]).find { |node| node.var_name == param.name }
       end
 
-      # :reek:FeatureEnvy
+      # @quality :reek:FeatureEnvy
       def unused_params
         exp.arguments.reject do |param|
           param.anonymous_splat? ||
             param.marked_unused? ||
-            uses_param?(param.plain_name)
+            uses_param?(param)
         end
       end
 
@@ -80,6 +76,17 @@ module Reek
       def non_public_visibility?
         visibility != :public
       end
+
+      def full_comment
+        own = super
+        return own unless own.empty?
+        return parent_exp.full_comment if parent_exp
+        ''
+      end
+
+      private
+
+      attr_reader :parent_exp
     end
   end
 end

data/lib/reek/context/module_context.rb

@@ -13,9 +13,8 @@ module Reek
     class ModuleContext < CodeContext
       attr_reader :visibility_tracker
 
-      def initialize(context, exp)
+      def initialize(exp)
         super
-
         @visibility_tracker = VisibilityTracker.new
       end
 
@@ -44,9 +43,9 @@ module Reek
         AttributeContext
       end
 
-      def defined_instance_methods(visibility: :public)
+      def defined_instance_methods(visibility: :any)
         instance_method_children.select do |context|
-          context.visibility == visibility
+          visibility == :any || context.visibility == visibility
         end
       end
 
@@ -60,7 +59,7 @@ module Reek
       # @deprecated use `defined_instance_methods` instead
       #
       def node_instance_methods
-        local_nodes(:def)
+        local_nodes(:def).to_a
       end
 
       def descriptively_commented?
@@ -74,7 +73,7 @@ module Reek
       #
       # @return true if the module is a namespace module
       #
-      # :reek:FeatureEnvy
+      # @quality :reek:FeatureEnvy
       def namespace_module?
         return false if exp.type == :casgn
         children = exp.direct_children
@@ -85,9 +84,6 @@ module Reek
         visibility_tracker.track_visibility children: instance_method_children,
                                             visibility: visibility,
                                             names: names
-      end
-
-      def track_singleton_visibility(visibility, names)
         visibility_tracker.track_singleton_visibility children: singleton_method_children,
                                                       visibility: visibility,
                                                       names: names

data/lib/reek/context/root_context.rb

@@ -9,10 +9,6 @@ module Reek
     # A context wrapper representing the root of an abstract syntax tree.
     #
     class RootContext < CodeContext
-      def initialize(exp)
-        super(nil, exp)
-      end
-
       def type
         :root
       end

data/lib/reek/context/send_context.rb

@@ -10,9 +10,9 @@ module Reek
     class SendContext < CodeContext
       attr_reader :name
 
-      def initialize(context, exp, name)
+      def initialize(exp, name)
         @name = name
-        super context, exp
+        super exp
       end
     end
   end