data_clump.rb in reek-6.0.0

- old
+ new

@@ -49,11 +49,11 @@
       # Checks the given class or module for multiple identical parameter sets.
       #
       # @return [Array<SmellWarning>]
       #
       def sniff
-        MethodGroup.new(context, min_clump_size, max_copies).clumps.map do |clump, methods|
+        clumps.map do |clump, methods|
           methods_length = methods.length
           smell_warning(
             lines: methods.map(&:line),
             message: "takes parameters #{DataClump.print_clump(clump)} " \
                      "to #{methods_length} methods",
@@ -70,74 +70,41 @@
       end
 
       private
 
       def max_copies
-        value(MAX_COPIES_KEY, context)
+        @max_copies ||= value(MAX_COPIES_KEY, context)
       end
 
       def min_clump_size
-        value(MIN_CLUMP_SIZE_KEY, context)
+        @min_clump_size ||= value(MIN_CLUMP_SIZE_KEY, context)
       end
-    end
-  end
 
-  # Represents a group of methods
-  # @private
-  class MethodGroup
-    def initialize(ctx, min_clump_size, max_copies)
-      @min_clump_size = min_clump_size
-      @max_copies = max_copies
-      @candidate_methods = ctx.node_instance_methods.map do |defn_node|
-        CandidateMethod.new(defn_node)
+      def candidate_methods
+        @candidate_methods ||= context.node_instance_methods
       end
-    end
 
-    def candidate_clumps
-      candidate_methods.each_cons(max_copies + 1).map do |methods|
-        common_argument_names_for(methods)
-      end.select do |clump|
-        clump.length >= min_clump_size
-      end.uniq
-    end
+      def candidate_clumps
+        candidate_methods.each_cons(max_copies + 1).map do |methods|
+          common_argument_names_for(methods)
+        end.select do |clump|
+          clump.length >= min_clump_size
+        end.uniq
+      end
 
-    # @quality :reek:UtilityFunction
-    def common_argument_names_for(methods)
-      methods.map(&:arg_names).inject(:&)
-    end
+      # @quality :reek:UtilityFunction
+      def common_argument_names_for(methods)
+        methods.map(&:arg_names).inject(:&).compact.sort
+      end
 
-    def methods_containing_clump(clump)
-      candidate_methods.select { |method| clump & method.arg_names == clump }
-    end
+      def methods_containing_clump(clump)
+        candidate_methods.select { |method| clump & method.arg_names == clump }
+      end
 
-    def clumps
-      candidate_clumps.map do |clump|
-        [clump, methods_containing_clump(clump)]
+      def clumps
+        candidate_clumps.map do |clump|
+          [clump, methods_containing_clump(clump)]
+        end
       end
     end
-
-    private
-
-    attr_reader :candidate_methods, :max_copies, :min_clump_size
-  end
-
-  # A method definition and a copy of its parameters
-  # @private
-  class CandidateMethod
-    extend Forwardable
-
-    def_delegators :defn, :line, :name
-
-    def initialize(defn_node)
-      @defn = defn_node
-    end
-
-    def arg_names
-      # TODO: Is all this sorting still needed?
-      @arg_names ||= defn.arg_names.compact.sort
-    end
-
-    private
-
-    attr_reader :defn
   end
 end