reek 3.1 → 3.2

data/lib/reek/smells/data_clump.rb

@@ -52,9 +52,9 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
-        @min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
-        MethodGroup.new(ctx, @min_clump_size, @max_copies).clumps.map do |clump, methods|
+        max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
+        min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
+        MethodGroup.new(ctx, min_clump_size, max_copies).clumps.map do |clump, methods|
           print_clump = DataClump.print_clump(clump)
           SmellWarning.new self,
                            context: ctx.full_name,
@@ -88,10 +88,10 @@ module Reek
     end
 
     def candidate_clumps
-      @candidate_methods.each_cons(@max_copies + 1).map do |methods|
+      candidate_methods.each_cons(max_copies + 1).map do |methods|
         common_argument_names_for(methods)
       end.select do |clump|
-        clump.length >= @min_clump_size
+        clump.length >= min_clump_size
       end.uniq
     end
 
@@ -100,7 +100,7 @@ module Reek
     end
 
     def methods_containing_clump(clump)
-      @candidate_methods.select { |method| clump & method.arg_names == clump }
+      candidate_methods.select { |method| clump & method.arg_names == clump }
     end
 
     def clumps
@@ -108,6 +108,10 @@ module Reek
         [clump, methods_containing_clump(clump)]
       end
     end
+
+    private
+
+    private_attr_reader :candidate_methods, :max_copies, :min_clump_size
   end
 
   # A method definition and a copy of its parameters
@@ -118,15 +122,19 @@ module Reek
     end
 
     def arg_names
-      @arg_names ||= @defn.arg_names.compact.sort
+      @arg_names ||= defn.arg_names.compact.sort
     end
 
     def line
-      @defn.line
+      defn.line
     end
 
     def name
-      @defn.name.to_s     # BUG: should report the symbols!
+      defn.name.to_s     # BUG: should report the symbols!
     end
+
+    private
+
+    private_attr_reader :defn
   end
 end

data/lib/reek/smells/duplicate_method_call.rb

@@ -68,20 +68,24 @@ module Reek
         end
 
         def record(occurence)
-          @occurences.push occurence
+          occurences.push occurence
         end
 
         def call
-          @call ||= @call_node.format_to_ruby
+          @call ||= call_node.format_to_ruby
         end
 
         def occurs
-          @occurences.length
+          occurences.length
         end
 
         def lines
-          @occurences.map(&:line)
+          occurences.map(&:line)
         end
+
+        private
+
+        private_attr_reader :call_node, :occurences
       end
 
       # Collects all calls in a given context
@@ -106,6 +110,8 @@ module Reek
 
         private
 
+        private_attr_reader :allow_calls, :max_allowed_calls
+
         def collect_calls(result)
           context.each_node(:send, [:mlhs]) do |call_node|
             next if call_node.object_creation_call?
@@ -118,7 +124,7 @@ module Reek
         end
 
         def smelly_call?(found_call)
-          found_call.occurs > @max_allowed_calls && !allow_calls?(found_call.call)
+          found_call.occurs > max_allowed_calls && !allow_calls?(found_call.call)
         end
 
         def simple_method_call?(call_node)
@@ -126,7 +132,7 @@ module Reek
         end
 
         def allow_calls?(method)
-          @allow_calls.any? { |allow| /#{allow}/ =~ method }
+          allow_calls.any? { |allow| /#{allow}/ =~ method }
         end
       end
     end

data/lib/reek/smells/long_parameter_list.rb

@@ -35,9 +35,9 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY, ctx, DEFAULT_MAX_ALLOWED_PARAMS)
+        max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY, ctx, DEFAULT_MAX_ALLOWED_PARAMS)
         count = ctx.exp.arg_names.length
-        return [] if count <= @max_allowed_params
+        return [] if count <= max_allowed_params
         [SmellWarning.new(self,
                           context: ctx.full_name,
                           lines: [ctx.exp.line],

data/lib/reek/smells/long_yield_list.rb

@@ -29,11 +29,11 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        @max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY,
-                                    method_ctx,
-                                    DEFAULT_MAX_ALLOWED_PARAMS)
+        max_allowed_params = value(MAX_ALLOWED_PARAMS_KEY,
+                                   method_ctx,
+                                   DEFAULT_MAX_ALLOWED_PARAMS)
         method_ctx.local_nodes(:yield).select do |yield_node|
-          yield_node.args.length > @max_allowed_params
+          yield_node.args.length > max_allowed_params
         end.map do |yield_node|
           count = yield_node.args.length
           SmellWarning.new self,

data/lib/reek/smells/nested_iterators.rb

@@ -50,8 +50,10 @@ module Reek
 
       private
 
+      private_attr_accessor :ignore_iterators
+
       def find_deepest_iterator(ctx)
-        @ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
+        self.ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
 
         find_iters(ctx.exp, 1).sort_by { |item| item[1] }.last
       end
@@ -73,7 +75,7 @@ module Reek
 
       def ignored_iterator?(exp)
         name = exp.call.method_name.to_s
-        @ignore_iterators.any? { |pattern| /#{pattern}/ =~ name }
+        ignore_iterators.any? { |pattern| /#{pattern}/ =~ name }
       end
     end
   end

data/lib/reek/smells/nil_check.rb

@@ -36,10 +36,14 @@ module Reek
         end
 
         def smelly_nodes
-          @nodes.select do |when_node|
-            @detector.detect(when_node)
+          nodes.select do |when_node|
+            detector.detect(when_node)
           end
         end
+
+        private
+
+        private_attr_reader :detector, :nodes
       end
 
       # Detect 'call' nodes which perform a nil check.

data/lib/reek/smells/repeated_conditional.rb

@@ -51,9 +51,9 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_identical_ifs = value(MAX_IDENTICAL_IFS_KEY, ctx, DEFAULT_MAX_IFS)
+        max_identical_ifs = value(MAX_IDENTICAL_IFS_KEY, ctx, DEFAULT_MAX_IFS)
         conditional_counts(ctx).select do |_key, lines|
-          lines.length > @max_identical_ifs
+          lines.length > max_identical_ifs
         end.map do |key, lines|
           occurs = lines.length
           expression = key.format_to_ruby

data/lib/reek/smells/smell_configuration.rb

@@ -17,8 +17,8 @@ module Reek
         @options = hash
       end
 
-      def merge!(options)
-        @options.merge!(options)
+      def merge!(new_options)
+        options.merge!(new_options)
       end
 
       #
@@ -26,11 +26,11 @@ module Reek
       #--
       #  SMELL: Getter
       def enabled?
-        @options[ENABLED_KEY]
+        options[ENABLED_KEY]
       end
 
       def overrides_for(context)
-        Overrides.new(@options.fetch(OVERRIDES_KEY, {})).for_context(context)
+        Overrides.new(options.fetch(OVERRIDES_KEY, {})).for_context(context)
       end
 
       # Retrieves the value, if any, for the given +key+.
@@ -39,8 +39,12 @@ module Reek
       #
       def value(key, context, fall_back)
         overrides_for(context).each { |conf| return conf[key] if conf.key?(key) }
-        @options.fetch(key, fall_back)
+        options.fetch(key, fall_back)
       end
+
+      private
+
+      private_attr_reader :options
     end
 
     #
@@ -54,9 +58,13 @@ module Reek
 
       # 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] }
+        contexts = hash.keys.select { |ckey| context.matches?([ckey]) }
+        contexts.map { |exc| hash[exc] }
       end
+
+      private
+
+      private_attr_reader :hash
     end
   end
 end

data/lib/reek/smells/smell_detector.rb

@@ -38,12 +38,17 @@ module Reek
         end
 
         def inherited(subclass)
-          @subclasses ||= []
-          @subclasses << subclass
+          subclasses << subclass
         end
 
         def descendants
-          @subclasses
+          subclasses
+        end
+
+        private
+
+        def subclasses
+          @subclasses ||= []
         end
       end
 
@@ -78,17 +83,17 @@ module Reek
       end
 
       def register(hooks)
-        return unless @config.enabled?
+        return unless config.enabled?
         self.class.contexts.each { |ctx| hooks[ctx] << self }
       end
 
       # SMELL: Getter (only used in 1 test)
       def enabled?
-        @config.enabled?
+        config.enabled?
       end
 
-      def configure_with(config)
-        @config.merge!(config)
+      def configure_with(new_config)
+        config.merge!(new_config)
       end
 
       def examine(context)
@@ -96,7 +101,7 @@ module Reek
         return if exception?(context)
 
         sm = examine_context(context)
-        @smells_found += sm
+        self.smells_found += sm
       end
 
       def enabled_for?(context)
@@ -108,16 +113,24 @@ module Reek
       end
 
       def report_on(report)
-        @smells_found.each { |smell| smell.report_on(report) }
+        smells_found.each { |smell| smell.report_on(report) }
       end
 
       def value(key, ctx, fall_back)
-        config_for(ctx)[key] || @config.value(key, ctx, fall_back)
+        config_for(ctx)[key] || config.value(key, ctx, fall_back)
       end
 
       def config_for(ctx)
         ctx.config_for(self.class)
       end
+
+      protected
+
+      attr_writer :smells_found
+
+      private
+
+      private_attr_reader :config
     end
   end
 end

data/lib/reek/smells/smell_repository.rb

@@ -16,10 +16,9 @@ module Reek
       def initialize(source_description: nil,
                      smell_types: self.class.smell_types,
                      configuration: Configuration::AppConfiguration.new)
-        self.source_via         = source_description
-        self.typed_detectors    = nil
-        self.configuration      = configuration
-        self.smell_types        = smell_types
+        @source_via    = source_description
+        @configuration = configuration
+        @smell_types   = smell_types
 
         configuration.directive_for(source_via).each do |klass, config|
           configure klass, config
@@ -43,25 +42,19 @@ module Reek
       end
 
       def detectors
-        @initialized_detectors ||= begin
-          @detectors = {}
-          smell_types.each do |klass|
-            @detectors[klass] = klass.new(source_via)
-          end
-          @detectors
-        end
+        @initialized_detectors ||= smell_types.map do |klass|
+          { klass => klass.new(source_via) }
+        end.reduce({}, :merge)
       end
 
       private
 
-      attr_accessor :typed_detectors, :configuration, :source_via, :smell_types
+      private_attr_reader :configuration, :source_via, :smell_types
 
       def smell_listeners
-        unless typed_detectors
-          self.typed_detectors = Hash.new { |hash, key| hash[key] = [] }
-          detectors.each_value { |detector| detector.register(typed_detectors) }
+        @smell_listeners ||= Hash.new { |hash, key| hash[key] = [] }.tap do |listeners|
+          detectors.each_value { |detector| detector.register(listeners) }
         end
-        typed_detectors
       end
     end
   end

data/lib/reek/smells/smell_warning.rb

@@ -8,15 +8,15 @@ module Reek
     class SmellWarning
       include Comparable
       extend Forwardable
-      attr_accessor :smell_detector, :context, :lines, :message, :parameters
+      attr_reader :context, :lines, :message, :parameters, :smell_detector
       def_delegators :smell_detector, :smell_category, :smell_type, :source
 
       def initialize(smell_detector, options = {})
-        self.smell_detector = smell_detector
-        self.context        = options.fetch(:context, '').to_s
-        self.lines          = options.fetch(:lines)
-        self.message        = options.fetch(:message)
-        self.parameters     = options.fetch(:parameters, {})
+        @smell_detector = smell_detector
+        @context        = options.fetch(:context, '').to_s
+        @lines          = options.fetch(:lines)
+        @message        = options.fetch(:message)
+        @parameters     = options.fetch(:parameters, {})
       end
 
       def hash

data/lib/reek/smells/too_many_instance_variables.rb

@@ -16,13 +16,13 @@ module Reek
       # The name of the config field that sets the maximum number of instance
       # variables permitted in a class.
       MAX_ALLOWED_IVARS_KEY = 'max_instance_variables'
-      DEFAULT_MAX_IVARS = 9
+      DEFAULT_MAX_IVARS = 4
 
       def self.smell_category
         'LargeClass'
       end
 
-      def self.contexts      # :nodoc:
+      def self.contexts
         [:class]
       end
 
@@ -39,9 +39,9 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx, DEFAULT_MAX_IVARS)
+        max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx, DEFAULT_MAX_IVARS)
         count = ctx.local_nodes(:ivasgn).map { |ivasgn| ivasgn[1] }.uniq.length
-        return [] if count <= @max_allowed_ivars
+        return [] if count <= max_allowed_ivars
         [SmellWarning.new(self,
                           context: ctx.full_name,
                           lines: [ctx.exp.line],

data/lib/reek/smells/too_many_methods.rb

@@ -41,9 +41,9 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx, DEFAULT_MAX_METHODS)
+        max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx, DEFAULT_MAX_METHODS)
         actual = ctx.node_instance_methods.length
-        return [] if actual <= @max_allowed_methods
+        return [] if actual <= max_allowed_methods
         [SmellWarning.new(self,
                           context: ctx.full_name,
                           lines: [ctx.exp.line],

data/lib/reek/smells/too_many_statements.rb

@@ -33,11 +33,11 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @max_allowed_statements = value(MAX_ALLOWED_STATEMENTS_KEY,
-                                        ctx,
-                                        DEFAULT_MAX_STATEMENTS)
+        max_allowed_statements = value(MAX_ALLOWED_STATEMENTS_KEY,
+                                       ctx,
+                                       DEFAULT_MAX_STATEMENTS)
         count = ctx.num_statements
-        return [] if count <= @max_allowed_statements
+        return [] if count <= max_allowed_statements
         [SmellWarning.new(self,
                           context: ctx.full_name,
                           lines: [ctx.exp.line],