pelusa 0.2.2 → 0.2.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjA3NTU1ZWZkNGViYTBmNTFhMmJmNGQ1MDZlNjQxNjcwYTJkMTA1ZQ==
+  data.tar.gz: !binary |-
+    NzEzMmJlNmE5N2ZhYTE3MjgyODMzMDgxMmEyMjYxMmFhYmZlZjBjOA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MjFmZmQyNzRiZWI3YjU0ZjE1MTNkNjViMmE5YTFiMzEwMjhiYWU1MGNiMWVi
+    YTI1ZDhiMjkwZjYyNjBhNGJhMThlOGQ0ZjE4M2FmMDBhZjhmNWQwMjRiNTBk
+    ZDgwOGQ5NzAzZmFiNTdkOTMwMTBmNmNhMWUwMDc4ZjIyMmI0OTM=
+  data.tar.gz: !binary |-
+    ODI4ZGVkOWE5MTgzMzdiOWYyNmNmYzMxZTNkOTRhY2E4M2FjNGQyOTRlYTg4
+    NDhmOTVkMWI0OWJkZTlmNjk3MjViNWEzMmUxYTRhMzMxNzQ5ZmY4ZWNjYTk5
+    OWQxOGUzZjFjZTQyNmI1OWZkODE3YjRkODUwNDkzMzgzY2RjY2I=

data/lib/pelusa.rb

@@ -24,8 +24,6 @@ require 'pelusa/lint'
 require 'pelusa/analysis'
 require 'pelusa/class_analyzer'
 require 'pelusa/report'
-require 'pelusa/iterator'
-
 
 require 'pelusa/reporters/reporter'
 require 'pelusa/reporters/stdout_reporter'

data/lib/pelusa/analyzer.rb

@@ -19,9 +19,10 @@ module Pelusa
       reports = extract_classes(ast).map do |klass|
         class_analyzer = ClassAnalyzer.new(klass)
         class_name     = class_analyzer.class_name
+        type           = class_analyzer.type
         analysis       = class_analyzer.analyze(@lints)
 
-        Report.new(class_name, analysis)
+        Report.new(class_name, type, analysis)
       end
       @reporter.reports = reports
       @reporter
@@ -38,10 +39,16 @@ module Pelusa
     # Returns an Array of Class nodes.
     def extract_classes(ast)
       classes = []
-      class_iterator = Iterator.new do |node|
-        classes << node if node.is_a?(Rubinius::AST::Class)
+      if ast.is_a?(Rubinius::AST::Class) || ast.is_a?(Rubinius::AST::Module)
+        classes << ast
+      end
+
+      ast.walk do |continue, node|
+        if node.is_a?(Rubinius::AST::Class) || node.is_a?(Rubinius::AST::Module)
+          classes << node
+        end
+        true
       end
-      Array(ast).each(&class_iterator)
       classes
     end
   end

data/lib/pelusa/class_analyzer.rb

@@ -14,6 +14,11 @@ class Pelusa::ClassAnalyzer
     name.name
   end
 
+  # Public: Returns the type of container being examined (class or module).
+  def type
+    @klass.is_a?(Rubinius::AST::Class) ? "class" : "module"
+  end
+
   # Public: Analyzes a class with a series of lints.
   #
   # lints - The lints to check for.
@@ -25,4 +30,15 @@ class Pelusa::ClassAnalyzer
       lint.check(@klass)
     end
   end
+
+  # Public: Walk a node, analyzing it as it goes.
+  #
+  # block - supply a block that will be executed as the node gets walked.
+  def self.walk(start_node)
+    raise ArgumentError, "Walk requires a block!" unless block_given?
+    start_node.walk do |continue, node|
+      yield(node)
+      true
+    end
+  end
 end

data/lib/pelusa/lint/case_statements.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -23,12 +22,11 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::Case)
             @violations << node.line
           end
         end
-        Array(klass).each(&iterator)
       end
     end
   end

data/lib/pelusa/lint/collection_wrappers.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -23,27 +22,35 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        array_assignment = nil
+        # the array of actual assignment nodes -- we only want to assign once
+        array_assignments = {}
+        # the name of all the assigned arrays, no others allowed
+        array_values = {}
 
-        get_array_assignment = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::InstanceVariableAssignment) &&
             (node.value.is_a?(Rubinius::AST::ArrayLiteral) ||
-            node.value.is_a?(Rubinius::AST::EmptyArray))
-              array_assignment = node
+             node.value.is_a?(Rubinius::AST::EmptyArray))
+            array_assignments[node] = true
+            array_values[node.name] = true
           end
         end
 
-        iterator = Iterator.new do |node|
-          next if node == array_assignment || !array_assignment
-
-          if node.is_a?(Rubinius::AST::InstanceVariableAssignment)
-            @violations << node.line
-          elsif node.is_a?(Rubinius::AST::InstanceVariableAccess) && node.name != array_assignment.name
-            @violations << node.line
+        unless array_assignments.empty?
+          ClassAnalyzer.walk(klass) do |node|
+            # if this is where we assign the node for the first time, good
+            unless array_assignments[node]
+              # otherwise, if it's an instance variable assignment, verboten!
+              if node.is_a?(Rubinius::AST::InstanceVariableAssignment)
+                @violations << node.line
+              # or if we access any other ivars
+              elsif node.is_a?(Rubinius::AST::InstanceVariableAccess) &&
+                !array_values[node.name]
+                @violations << node.line
+              end
+            end
           end
         end
-        Array(klass).each(&get_array_assignment)
-        Array(klass).each(&iterator)
       end
     end
   end

data/lib/pelusa/lint/demeter_law.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -23,17 +22,44 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::Send) && node.receiver.is_a?(Rubinius::AST::Send)
             @violations << node.line unless white_listed?(node.receiver.name)
           end
         end
-        Array(klass).each(&iterator)
+      end
+
+      # Internal: Default modules whose methods are whitelisted.
+      DEFAULT_WHITELIST = [Class, Fixnum, Enumerable]
+
+      # Internal: Methods on these common, fundamental classes and modules are
+      # allowed to be called on other objects.
+      #
+      # Note: this doesn't currently work with namespaced objects, but would be
+      # easy to extend.
+      #
+      # Returns an array of classes specified in .pelusa.yml (a comma-separated
+      # list of class names) or the default values above.
+      def whitelist_sources
+        if whitelist = Pelusa.configuration['DemeterLaw']['whitelist']
+          whitelist.split(",").map {|k| Kernel.const_get(k.strip)}
+        else
+          DEFAULT_WHITELIST
+        end
+      end
+
+      # Internal: Allow conversion methods -- matching /^(to_|as_)/ to violate
+      # the law of Demeter.
+      def allow_conversions?
+        Pelusa.configuration['DemeterLaw'].fetch('allow_conversions', false)
       end
 
       def white_listed? method
-        [Class, Fixnum, Enumerable].any? do |enclosing_module|
-          enclosing_module.instance_methods.any? {|instance_method| instance_method == method }
+        whitelist_sources.any? do |enclosing_module|
+          enclosing_module.instance_methods.any? do |instance_method|
+            instance_method == method or
+              allow_conversions? && instance_method =~ /^(to_|as_)/
+          end
         end
       end
     end

data/lib/pelusa/lint/else_clauses.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -23,7 +22,7 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::If)
             has_body = node.body && !node.body.is_a?(Rubinius::AST::NilLiteral)
             has_else = node.else && !node.else.is_a?(Rubinius::AST::NilLiteral)
@@ -33,7 +32,6 @@ module Pelusa
             end
           end
         end
-        Array(klass).each(&iterator)
       end
     end
   end

data/lib/pelusa/lint/eval_usage.rb

@@ -3,7 +3,6 @@
 module Pelusa
   module Lint
     class EvalUsage
-
       def initialize
         @violations = Set.new
       end
@@ -27,10 +26,9 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           @violations << node.line if eval_violation?(node)
         end
-        Array(klass).each(&iterator)
       end
 
       def eval_violation?(node)

data/lib/pelusa/lint/indentation_level.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -23,24 +22,33 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        # we want to find all nodes inside define blocks that
+        # contain > 1 indentation levels
+        # this method totally fails the IndentationLevel level lint :P
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::Define)
-            _iterate = Iterator.new do |node|
-              __iterate = Iterator.new do |node|
-                if body = get_body_from_node[node]
-                  if node.line != [body].flatten.first.line
-                    @violations.merge Array(body).map(&:line)
+            # we're inside a method body, so see if we indent anywhere
+            ClassAnalyzer.walk(node) do |inner_node|
+              if inner_body = get_body_from_node[inner_node]
+                # if it turns out there's an indented value in there, that
+                # could be okay -- walk that node to see if there's a 2nd level
+                if inner_node.line != [inner_body].flatten.first.line
+                  # walk the third level, see if there's another indent
+                  ClassAnalyzer.walk(inner_node) do |innermost_node|
+                    if innermost_body = get_body_from_node[innermost_node]
+                      if innermost_node.line != [innermost_body].flatten.first.line
+                        # there's yet another level of indent -- violation!
+                        # note: this also catches bad outdents, possibly should
+                        # flag those separately
+                        @violations.merge Array(innermost_body).map(&:line)
+                      end
+                    end
                   end
                 end
               end
-
-              Array(get_body_from_node[node]).each(&__iterate)
             end
-            node.body.array.each(&_iterate)
           end
         end
-
-        Array(klass).each(&iterator)
       end
 
       def get_body_from_node

data/lib/pelusa/lint/instance_variables.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @ivars.length < limit
@@ -27,12 +26,11 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::InstanceVariableAccess) || node.is_a?(Rubinius::AST::InstanceVariableAssignment)
             @ivars << node.name
           end
         end
-        Array(klass).each(&iterator)
       end
     end
   end

data/lib/pelusa/lint/line_restriction.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if lines < limit
@@ -31,10 +30,9 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           @lines << node.line if node.respond_to?(:line)
         end
-        Array(klass).each(&iterator)
       end
     end
   end

data/lib/pelusa/lint/long_identifiers.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -27,16 +26,14 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.respond_to?(:name)
             name = node.name.respond_to?(:name) ? node.name.name.to_s : node.name.to_s
             if name =~ /[a-z]/ && name.length > limit
-              next if name =~ /^[A-Z]/ # Ignore constants
-              @violations << [name, node.line]
+              @violations << [name, node.line] unless name =~ /^[A-Z]/ # Ignore constants
             end
           end
         end
-        Array(klass).each(&iterator)
       end
 
       def formatted_violations

data/lib/pelusa/lint/many_arguments.rb

@@ -6,8 +6,8 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
+
         return SuccessfulAnalysis.new(name) if @violations.empty?
 
         FailedAnalysis.new(name, formatted_violations) do |violations|
@@ -26,12 +26,11 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::Define) && node.arguments.total_args > limit
             @violations << node.name
           end
         end
-        Array(klass).each(&iterator)
       end
 
       def formatted_violations

data/lib/pelusa/lint/properties.rb

@@ -6,7 +6,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -23,14 +22,13 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.is_a?(Rubinius::AST::Send)
             if [:attr_accessor, :attr_writer, :attr_reader].include? node.name
               @violations << node.line
             end
           end
         end
-        Array(klass).each(&iterator)
       end
     end
   end

data/lib/pelusa/lint/short_identifiers.rb

@@ -8,7 +8,6 @@ module Pelusa
       end
 
       def check(klass)
-        initialize
         iterate_lines!(klass)
 
         return SuccessfulAnalysis.new(name) if @violations.empty?
@@ -25,16 +24,14 @@ module Pelusa
       end
 
       def iterate_lines!(klass)
-        iterator = Iterator.new do |node|
+        ClassAnalyzer.walk(klass) do |node|
           if node.respond_to?(:name)
             name = node.name.respond_to?(:name) ? node.name.name.to_s : node.name.to_s
             if name =~ /[a-z]/ && name.length < 3 && !RESERVED_NAMES.include?(name)
-              next if name =~ /^[A-Z]/ # Ignore constants
-              @violations << [name, node.line]
+              @violations << [name, node.line] unless name =~ /^[A-Z]/ # Ignore constants
             end
           end
         end
-        Array(klass).each(&iterator)
       end
 
       def formatted_violations

data/lib/pelusa/report.rb

@@ -6,19 +6,15 @@ module Pelusa
     # Public: Initializes a new Report.
     #
     # class_name - The Symbol name of the class being analyzed.
+    # type       - the String type of the class being analyzed (class or module).
     # analyses   - An Array of Analysis objects.
-    def initialize(class_name, analyses)
-      @class_name = class_name
+    def initialize(name, type, analyses)
+      @class_name = name
+      @type       = type
       @analyses   = analyses
     end
 
-    def class_name
-      @class_name
-    end
-
-    def analyses
-      @analyses
-    end
+    attr_reader :class_name, :type, :analyses
 
     def successful?
       @analyses.all? { |analysis| analysis.successful? }

data/lib/pelusa/reporters/stdout_reporter.rb

@@ -21,7 +21,7 @@ module Pelusa
     def print_report(class_report)
       class_name = class_report.class_name
 
-      puts "  class #{class_name}"
+      puts "  #{class_report.type} #{class_name}"
 
       analyses = class_report.analyses
       analyses.each do |analysis|

data/lib/pelusa/version.rb

@@ -1,3 +1,3 @@
 module Pelusa
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/test/pelusa/analyzer_test.rb

@@ -3,30 +3,60 @@ require 'test_helper'
 module Pelusa
   describe Analyzer do
     describe '#analyze' do
-      before do
-        @ast = """
-          class Foo
-            def bar
-              123
+      describe 'with a multi-expression AST' do
+        before do
+          @ast = """
+            class Foo
+              def bar
+                123
+              end
             end
-          end
 
-          class Bar
-            def baz
-              321
+            class Bar
+              def baz
+                321
+              end
             end
-          end
-        """.to_ast
 
-        lints = stub
-        @analyzer = Analyzer.new([Lint::LineRestriction], RubyReporter, "foo.rb")
+            module Baz
+              def bar
+                2.7
+              end
+            end
+          """.to_ast
+
+          lints = stub
+          @analyzer = Analyzer.new([Lint::LineRestriction], RubyReporter, "foo.rb")
+        end
+
+        it 'analyzes an ast and returns a report' do
+          result = @analyzer.analyze(@ast).report
+          result[:filename].must_equal "foo.rb"
+          result[:Foo]["Is below 50 lines"][:status].must_equal "successful"
+          result[:Bar]["Is below 50 lines"][:status].must_equal "successful"
+          result[:Baz]["Is below 50 lines"][:status].must_equal "successful"
+        end
       end
 
-      it 'analyzes an ast and returns a report' do
-        result = @analyzer.analyze(@ast).report
-        result[:filename].must_equal "foo.rb"
-        result[:Foo]["Is below 50 lines"][:status].must_equal "successful"
-        result[:Bar]["Is below 50 lines"][:status].must_equal "successful"
+      describe 'with a single-expression AST' do
+        before do
+          @ast = """
+            class Foo
+              def bar
+                123
+              end
+            end
+          """.to_ast
+
+          lints = stub
+          @analyzer = Analyzer.new([Lint::LineRestriction], RubyReporter, "foo.rb")
+        end
+
+        it 'analyzes an ast and returns a report' do
+          result = @analyzer.analyze(@ast).report
+          result[:filename].must_equal "foo.rb"
+          result[:Foo]["Is below 50 lines"][:status].must_equal "successful"
+        end
       end
     end
   end

data/test/pelusa/class_analyzer_test.rb

@@ -21,6 +21,20 @@ module Pelusa
           @analyzer.class_name.must_equal "Foo"
         end
       end
+
+      describe "#type" do
+        it "returns the type module for modules" do
+          # hacky!
+          @klass.stubs(:is_a?).with(Rubinius::AST::Class).returns(true)
+          @analyzer.type.must_equal "class"
+        end
+
+        it "returns the type module for modules" do
+          # hacky!
+          @klass.stubs(:is_a?).with(Rubinius::AST::Class).returns(false)
+          @analyzer.type.must_equal "module"
+        end
+      end
     end
   end
 end

data/test/pelusa/lint/collection_wrappers_test.rb

@@ -22,6 +22,20 @@ module Pelusa
           end
         end
 
+        describe 'when the class has no ivars' do
+          it 'returns a SuccessAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                things = []
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+        end
+
         describe 'when the class mixes collection ivars with others' do
           it 'returns a FailureAnalysis' do
             klass = """
@@ -36,6 +50,37 @@ module Pelusa
             analysis.failed?.must_equal true
           end
         end
+
+        describe 'when the class has multiple array assignments' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                @things = []
+                @foos = []
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal false
+          end
+        end
+
+        describe 'when the class has multiple array and other assignments' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                @things = []
+                @foos = []
+                @foo = 'bar'
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
       end
     end
   end

data/test/pelusa/lint/demeter_law_test.rb

@@ -47,36 +47,92 @@ module Pelusa
             end""".to_ast
 
             analysis = @lint.check(klass)
-            analysis.successful?.must_equal true              
+            analysis.successful?.must_equal true
           end
         end
 
-        describe 'when chaining operations on an Enumerable' do
-          it 'returns a SuccessAnalysis' do
+        describe 'when chaining whitelisted operations' do
+          it 'returns a SuccessAnalysis for chained operations from Enumerable' do
+            klass = """
+            class Foo
+              def execute
+                [1,2,3].map(&:object_id).each {|i| i}
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+
+          it 'returns a SuccessAnalysis when chaining methods from Fixnum' do
+            klass = """
+            class Foo
+              def execute
+                1 + 2 + 3 + 4
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+
+          it 'returns a SuccessAnalysis for chained operations from Object' do
+            klass = """
+            class Foo
+              def execute
+                Object.new.to_s.inspect
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+
+          it 'returns a SuccessAnalysis for chained operations from optional sources' do
+            Pelusa.configuration.stubs(:[]).with("DemeterLaw").returns(
+              {"whitelist" => "Object, Kernel, Hash, Enumerable"}
+            )
+
             klass = """
             class Foo
               def execute
-                [1,2,3].map(&:object_id).map(&:object_id)
+                {'a' => 2}.merge.each_pair {|k, v|}
               end
             end""".to_ast
 
             analysis = @lint.check(klass)
-            analysis.successful?.must_equal true              
+            analysis.successful?.must_equal true
           end
         end
-      end
 
-      describe 'when chaining Fixnum operations' do
-        it 'returns a SuccessAnalysis' do
-          klass = """
-          class Foo
-            def execute
-              1 + 2 + 3 + 4
-            end
-          end""".to_ast
-
-          analysis = @lint.check(klass)
-          analysis.successful?.must_equal true              
+        describe 'conversions' do
+          it 'returns a SuccessAnalysis for conversion operations if allowed' do
+            Pelusa.configuration.stubs(:[]).with("DemeterLaw").returns(
+              {"allow_conversions" => true}
+            )
+
+            klass = """
+            class Foo
+              def execute
+                {'a' => 2}.merge({}).to_hash.as_json
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+
+          it 'returns a FailureAnalysis for conversions if not allowed' do
+            klass = """
+            class Foo
+              def execute
+                {'a' => 2}.merge({}).to_hash
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal false
+          end
         end
       end
     end

data/test/pelusa/reporters/ruby_reporter_test.rb

@@ -10,8 +10,8 @@ module Pelusa
         okay = SuccessfulAnalysis.new("Is below 50 lines")
 
         @reports =  [
-          Report.new("Foo", [ too_many_lines ]),
-          Report.new("Bar", [ okay ])
+          Report.new("Foo", "class", [ too_many_lines ]),
+          Report.new("Bar", "module", [ okay ])
         ]
 
         @reporter = RubyReporter.new('foo.rb')

data/test/test_helper.rb

@@ -1,6 +1,6 @@
 require 'minitest/autorun'
 require 'minitest/spec'
-require 'mocha'
+require 'mocha/setup'
 
 require 'pelusa'
 

metadata

@@ -1,32 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: pelusa
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Josep M. Bach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-14 00:00:00.000000000 Z
+date: 2013-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  prerelease: false
-  type: :development
-  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
+        version: !binary |-
+          MA==
+  name: mocha
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
+        version: !binary |-
+          MA==
+  prerelease: false
+  type: :development
 description: Static analysis Lint-type tool to improve your OO Ruby code
 email:
 - josep.m.bach@gmail.com
@@ -49,7 +48,6 @@ files:
 - lib/pelusa/class_analyzer.rb
 - lib/pelusa/cli.rb
 - lib/pelusa/configuration.rb
-- lib/pelusa/iterator.rb
 - lib/pelusa/lint.rb
 - lib/pelusa/lint/case_statements.rb
 - lib/pelusa/lint/collection_wrappers.rb
@@ -76,7 +74,6 @@ files:
 - test/pelusa/class_analyzer_test.rb
 - test/pelusa/cli_test.rb
 - test/pelusa/configuration_test.rb
-- test/pelusa/iterator_test.rb
 - test/pelusa/lint/case_statements_test.rb
 - test/pelusa/lint/collection_wrappers_test.rb
 - test/pelusa/lint/demeter_law_test.rb
@@ -95,6 +92,7 @@ files:
 - test/test_helper.rb
 homepage: http://github.com/codegram/pelusa
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -103,19 +101,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-  none: false
+      version: !binary |-
+        MA==
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-  none: false
+      version: !binary |-
+        MA==
 requirements: []
 rubyforge_project: pelusa
-rubygems_version: 1.8.24
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Static analysis Lint-type tool to improve your OO Ruby code
 test_files:
 - test/pelusa_test.rb
@@ -125,7 +123,6 @@ test_files:
 - test/pelusa/class_analyzer_test.rb
 - test/pelusa/cli_test.rb
 - test/pelusa/configuration_test.rb
-- test/pelusa/iterator_test.rb
 - test/pelusa/runner_test.rb
 - test/pelusa/lint/case_statements_test.rb
 - test/pelusa/lint/collection_wrappers_test.rb

data/lib/pelusa/iterator.rb

@@ -1,39 +0,0 @@
-module Pelusa
-  class Iterator
-    NodeIterator = lambda do |node, check|
-      check.call(node)
-
-      if node.respond_to?(:each)
-        return node.each { |node| NodeIterator.call(node, check) }
-      end
-
-      ivars    = node.instance_variables
-      children = ivars.map { |ivar| node.instance_variable_get(ivar) }
-
-      return children.each { |node| NodeIterator.call(node, check) }
-    end
-
-    # Public: Initializes a new Iterator with a particular lint check.
-    #
-    # lint - The lint block that yields a node to assert for particular
-    # conditions in that node.
-    def initialize(&lint)
-      @iterator = lambda { |node| NodeIterator.call(node, lint) }
-    end
-
-    # Public: Calls the iterator with the given arguments.
-    #
-    # node - The root node from which to iterate.
-    def call(node)
-      @iterator.call(node)
-    end
-
-    # Public: Returns the iterator. Useful when using symbol to proc
-    # conversions, such as &iterator.
-    #
-    # Returns the Proc iterator.
-    def to_proc
-      @iterator
-    end
-  end
-end

data/test/pelusa/iterator_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-module Pelusa
-  describe Iterator do
-    before do
-      @last_node = nil
-      @iterator  = Iterator.new do |node|
-        @last_node = node if node == 3
-      end
-
-      @node = [ [ 1, [ 2, 3 ] ] ]
-    end
-
-    describe '#call' do
-      it 'calls the iterator on a node' do
-        @iterator.call(@node)
-        @last_node.must_equal 3
-      end
-    end
-
-    describe '#to_proc' do
-      it 'calls the iterator on a node' do
-        @iterator.to_proc[@node]
-        @last_node.must_equal 3
-      end
-    end
-  end
-end