reek 3.2.1 → 3.3.0

data/lib/reek/smells/attribute.rb

@@ -17,15 +17,12 @@ module Reek
     #
     # TODO: Catch attributes declared "by hand"
     class Attribute < SmellDetector
-      ATTR_DEFN_METHODS = [:attr_writer, :attr_accessor]
-      VISIBILITY_MODIFIERS = [:private, :public, :protected]
-
       def initialize(*args)
         super
       end
 
       def self.contexts # :nodoc:
-        [:class, :module]
+        [:sym]
       end
 
       #
@@ -34,13 +31,11 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @visiblity_tracker = {}
-        @visiblity_mode = :public
         attributes_in(ctx).map do |attribute, line|
           SmellWarning.new self,
                            context: ctx.full_name,
                            lines: [line],
-                           message:  "declares the writable attribute #{attribute}",
+                           message:  'is a writable attribute',
                            parameters: { name: attribute.to_s }
         end
       end
@@ -48,55 +43,13 @@ module Reek
       private
 
       def attributes_in(module_ctx)
-        attributes = Set.new
-        module_ctx.local_nodes(:send) do |call_node|
-          attributes += track_attributes(call_node)
-        end
-        attributes.select { |name, _line| recorded_public_methods.include?(name) }
-      end
-
-      def track_attributes(call_node)
-        if attribute_writer? call_node
-          return track_arguments call_node.args, call_node.line
-        end
-        track_visibility call_node if visibility_modifier? call_node
-        []
-      end
-
-      def attribute_writer?(call_node)
-        ATTR_DEFN_METHODS.include?(call_node.method_name) ||
-          attr_with_writable_flag?(call_node)
-      end
-
-      def attr_with_writable_flag?(call_node)
-        call_node.method_name == :attr && call_node.args.last.type == :true
-      end
-
-      def track_arguments(args, line)
-        args.select { |arg| arg.type == :sym }.map { |arg| track_argument(arg, line) }
-      end
-
-      def track_argument(arg, line)
-        arg_name = arg.children.first
-        @visiblity_tracker[arg_name] = @visiblity_mode
-        [arg_name, line]
-      end
-
-      def visibility_modifier?(call_node)
-        VISIBILITY_MODIFIERS.include?(call_node.method_name)
-      end
-
-      def track_visibility(call_node)
-        if call_node.arg_names.any?
-          call_node.arg_names.each { |arg| @visiblity_tracker[arg] = call_node.method_name }
+        if module_ctx.visibility == :public
+          call_node = module_ctx.exp
+          [[call_node.name, call_node.line]]
         else
-          @visiblity_mode = call_node.method_name
+          []
         end
       end
-
-      def recorded_public_methods
-        @visiblity_tracker.select { |_, visbility| visbility == :public }
-      end
     end
   end
 end

data/lib/reek/smells/control_parameter.rb

@@ -73,16 +73,20 @@ module Reek
         end
 
         def smells?
-          @occurences.any?
+          occurences.any?
         end
 
         def lines
-          @occurences.map(&:line)
+          occurences.map(&:line)
         end
 
         def name
-          @param.to_s
+          param.to_s
         end
+
+        private
+
+        private_attr_reader :occurences, :param
       end
 
       # Finds cases of ControlParameter in a particular node for a particular parameter
@@ -108,13 +112,15 @@ module Reek
 
         private
 
+        private_attr_reader :node, :param
+
         def conditional_nodes
-          @node.body_nodes(CONDITIONAL_NODE_TYPES)
+          node.body_nodes(CONDITIONAL_NODE_TYPES)
         end
 
         def nested_finders
           @nested_finders ||= conditional_nodes.flat_map do |node|
-            self.class.new(node, @param)
+            self.class.new(node, param)
           end
         end
 
@@ -129,12 +135,12 @@ module Reek
 
         def uses_of_param_in_condition
           return [] unless condition
-          condition.each_node(:lvar).select { |inner| inner.var_name == @param }
+          condition.each_node(:lvar).select { |inner| inner.var_name == param }
         end
 
         def condition
-          return nil unless CONDITIONAL_NODE_TYPES.include? @node.type
-          @node.condition
+          return nil unless CONDITIONAL_NODE_TYPES.include? node.type
+          node.condition
         end
 
         def regular_call_involving_param?(call_node)
@@ -150,12 +156,12 @@ module Reek
         end
 
         def call_involving_param?(call_node)
-          call_node.each_node(:lvar).any? { |it| it.var_name == @param }
+          call_node.each_node(:lvar).any? { |it| it.var_name == param }
         end
 
         def uses_param_in_body?
-          nodes = @node.body_nodes([:lvar], [:if, :case, :and, :or])
-          nodes.any? { |lvar_node| lvar_node.var_name == @param }
+          nodes = node.body_nodes([:lvar], [:if, :case, :and, :or])
+          nodes.any? { |lvar_node| lvar_node.var_name == param }
         end
       end
 
@@ -175,12 +181,14 @@ module Reek
 
         private
 
+        private_attr_reader :context
+
         def potential_parameters
-          @context.exp.parameter_names
+          context.exp.parameter_names
         end
 
         def find_matches(param)
-          ControlParameterFinder.new(@context.exp, param).find_matches
+          ControlParameterFinder.new(context.exp, param).find_matches
         end
       end
     end

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

@@ -37,7 +37,7 @@ module Reek
 
       BLOCK_GIVEN_CONDITION = ::Parser::AST::Node.new(:send, [nil, :block_given?])
 
-      def self.contexts      # :nodoc:
+      def self.contexts # :nodoc:
         [:class]
       end
 
@@ -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

@@ -1,3 +1,5 @@
+require 'private_attr/everywhere'
+
 module Reek
   module Smells
     #
@@ -17,8 +19,8 @@ module Reek
         @options = hash
       end
 
-      def merge!(options)
-        @options.merge!(options)
+      def merge!(new_options)
+        options.merge!(new_options)
       end
 
       #
@@ -26,11 +28,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 +41,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 +60,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