pelusa 0.0.1

data/lib/pelusa/runner.rb

@@ -0,0 +1,53 @@
+module Pelusa
+  class Runner
+    # Public: Initializes an Analyzer.
+    #
+    # lints    - The lints to check the code for.
+    # reporter - The Reporter to use. Will be used to report back the results in
+    #            methods such as #run.
+    def initialize(lints, reporter)
+      @lints    = lints
+      @reporter = reporter
+    end
+
+    # Public: Runs the analyzer on a set of files.
+    #
+    # Returns an Array of Reports of those file runs.
+    def run(files)
+      reporters = Array(files).map do |file|
+        run_file(file)
+      end
+      @reporter.print_banner
+
+      exit_code = 0
+
+      reporters.each do |reporter|
+        reporter.report
+        exit_code = 1 unless reporter.successful?
+      end
+      exit_code
+    end
+
+    # Public: Runs the analyzer on a single file.
+    #
+    # Returns a Report of the single run.
+    def run_file(file)
+      ast      = parser.parse_file(file)
+      analyzer = Analyzer.new(@lints, @reporter, file)
+      analyzer.analyze(ast)
+    end
+
+    #######
+    private
+    #######
+
+    # Internal: Returns the parser used to analyze the files, depending on the
+    # current Rubinius mode.
+    #
+    # Returns a Rubinius::Melbourne parser.
+    def parser
+      return Rubinius::Melbourne19 if ENV['RBXOPT'].include?("-X19")
+      Rubinius::Melbourne
+    end
+  end
+end

data/lib/pelusa/version.rb

@@ -0,0 +1,3 @@
+module Pelusa
+  VERSION = "0.0.1"
+end

data/pelusa.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pelusa/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pelusa"
+  s.version     = Pelusa::VERSION
+  s.authors     = ["Josep M. Bach"]
+  s.email       = ["josep.m.bach@gmail.com"]
+  s.homepage    = "http://github.com/codegram/pelusa"
+  s.summary     = %q{Static analysis Lint-type tool to improve your OO Ruby code}
+  s.description = %q{Static analysis Lint-type tool to improve your OO Ruby code}
+
+  s.rubyforge_project = "pelusa"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = Dir["test/**/*.rb"]
+  s.executables   = ["pelusa"]
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'mocha'
+end

data/test/pelusa/analysis_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Pelusa
+  describe SuccessfulAnalysis do
+    before do
+      @analysis = SuccessfulAnalysis.new("Is awesome")
+    end
+
+    it 'is successful' do
+      @analysis.successful?.must_equal true
+    end
+
+    describe '#message' do
+      it 'has an empty message' do
+        @analysis.message.empty?.must_equal true
+      end
+    end
+  end
+
+  describe FailedAnalysis do
+    before do
+      number_of_errors = 42
+      @analysis = FailedAnalysis.new("Is awesome", number_of_errors) do |errors|
+        "There have been #{errors} errors."
+      end
+    end
+
+    it 'is failed' do
+      @analysis.failed?.must_equal true
+    end
+
+    describe '#message' do
+      it 'describes the failed analysis' do
+        @analysis.message.must_equal "There have been 42 errors."
+      end
+    end
+  end
+end

data/test/pelusa/analyzer_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Pelusa
+  describe Analyzer do
+    describe '#analyze' do
+      before do
+        @ast = """
+          class Foo
+            def bar
+              123
+            end
+          end
+
+          class Bar
+            def baz
+              321
+            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"
+      end
+    end
+  end
+end

data/test/pelusa/class_analyzer_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Pelusa
+  describe ClassAnalyzer do
+    describe '#analyze' do
+      before do
+        @lints = [
+          stub(new: stub(check: true)),
+          stub(new: stub(check: true))
+        ]
+        @klass    = stub(name: stub(name: "Foo"))
+        @analyzer = ClassAnalyzer.new(@klass)
+      end
+
+      it 'analyzes a Class node for a series of lints' do
+        @analyzer.analyze(@lints).must_equal [true, true]
+      end
+
+      describe '#class_name' do
+        it 'returns the name of the analyzed class' do
+          @analyzer.class_name.must_equal "Foo"
+        end
+      end
+    end
+  end
+end

data/test/pelusa/iterator_test.rb

@@ -0,0 +1,28 @@
+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

data/test/pelusa/lint/collection_wrappers_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Pelusa
+  module Lint
+    describe CollectionWrappers do
+      before do
+        @lint = CollectionWrappers.new
+      end
+
+      describe '#check' do
+        describe 'when the class is not a collection wrapper with more instance variables' 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 = """
+            class Foo
+              def initialize
+                @things = []
+                @foo = 'bar'
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
+      end
+    end
+  end
+end

data/test/pelusa/lint/demeter_law_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Pelusa
+  module Lint
+    describe DemeterLaw do
+      before do
+        @lint = DemeterLaw.new
+      end
+
+      describe '#check' do
+        describe 'when the class respects Demeter law' do
+          it 'returns a SuccessAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                foo = 'hey'.upcase
+                foo.downcase
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+        end
+
+        describe 'when the class does not respect Demeter law' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                foo = 'hey'.upcase.downcase
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
+      end
+    end
+  end
+end

data/test/pelusa/lint/else_clauses_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Pelusa
+  module Lint
+    describe ElseClauses do
+      before do
+        @lint = ElseClauses.new
+      end
+
+      describe '#check' do
+        describe 'when the class does not use else clauses' do
+          it 'returns a SuccessAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                if 3
+                  8
+                end
+                unless 9
+                  3
+                end
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+        end
+
+        describe 'when the class uses else clauses' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                if 3
+                  8
+                else
+                  9
+                end
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
+      end
+    end
+  end
+end

data/test/pelusa/lint/indentation_level_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Pelusa
+  module Lint
+    describe IndentationLevel do
+      before do
+        @lint = IndentationLevel.new
+      end
+
+      describe '#check' do
+        describe 'when the class has one method with one or less indentation levels' do
+          it 'returns a SuccessAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                if 9
+                  3
+                end
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+        end
+
+        describe 'when the class has one method with more than one indentation level' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                if 9
+                  unless 3
+                    5
+                  end
+                end
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
+      end
+    end
+  end
+end

data/test/pelusa/lint/instance_variables_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Pelusa
+  module Lint
+    describe InstanceVariables do
+      before do
+        @lint = InstanceVariables.new
+      end
+
+      describe '#check' do
+        describe 'when the class uses less than 3 ivars' do
+          it 'returns a SuccessAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                @foo = 1
+                @bar = 2
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+        end
+
+        describe 'when the class has more than 50 lines' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              def initialize
+                @foo = 1
+                @bar = 2
+                @baz = 3
+              end
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
+      end
+    end
+  end
+end

data/test/pelusa/lint/line_restriction_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Pelusa
+  module Lint
+    describe LineRestriction do
+      before do
+        @lint = LineRestriction.new
+      end
+
+      describe '#check' do
+        describe 'when the class has less than 50 lines' do
+          it 'returns a SuccessAnalysis' do
+            klass = """
+            class Foo
+              attr_accessor :foo
+              attr_accessor :bar
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.successful?.must_equal true
+          end
+        end
+
+        describe 'when the class has more than 50 lines' do
+          it 'returns a FailureAnalysis' do
+            klass = """
+            class Foo
+              attr_accessor :foo
+              #{"\n" * 80}
+              attr_accessor :bar
+            end""".to_ast
+
+            analysis = @lint.check(klass)
+            analysis.failed?.must_equal true
+          end
+        end
+      end
+    end
+  end
+end