simplabs-excellent 1.0.0

data/lib/simplabs/excellent/core/extensions/underscore.rb

@@ -0,0 +1,27 @@
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      module Extensions
+
+        ::String.class_eval do
+
+          def underscore
+            to_s.gsub(/::/, '/').
+              gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+              gsub(/([a-z\d])([A-Z])/,'\1_\2').
+              tr("-", "_").
+              downcase
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/core/iterator_visitor.rb

@@ -0,0 +1,29 @@
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      class IteratorVisitor
+
+    	  def initialize(payload)
+      	  @payload = payload
+    	  end
+	
+    	  def visit(visited)
+    		  visited.accept(@payload)
+    		  visitable_nodes = visited.is_language_node? ? visited.sexp_body : visited
+    		  visitable_nodes.each do |child|
+    		    if child.is_a?(Sexp) then
+      		    child.accept(self)
+    		    end
+  		    end
+    	  end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/core/parse_tree_runner.rb

@@ -0,0 +1,88 @@
+require 'pp'
+require 'yaml'
+
+require 'simplabs/excellent/core/checking_visitor'
+require 'simplabs/excellent/core/iterator_visitor'
+require 'simplabs/excellent/core/parser'
+require 'simplabs/excellent/core/visitable_sexp'
+
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      class ParseTreeRunner
+
+        DEFAULT_CONFIG = {
+          :AssignmentInConditionalCheck    => { },
+          :CaseMissingElseCheck            => { },
+          :ClassLineCountCheck             => { :threshold      => 300 },
+          :ClassNameCheck                  => { :pattern         => /^[A-Z][a-zA-Z0-9]*$/ },
+          :ClassVariableCheck              => { },
+          :CyclomaticComplexityBlockCheck  => { :complexity      => 4 },
+          :CyclomaticComplexityMethodCheck => { :complexity      => 8 },
+          :EmptyRescueBodyCheck            => { },
+          :ForLoopCheck                    => { },
+          :MethodLineCountCheck            => { :line_count      => 20 },
+          :MethodNameCheck                 => { :pattern         => /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ },
+          :ModuleLineCountCheck            => { :line_count      => 300 },
+          :ModuleNameCheck                 => { :pattern         => /^[A-Z][a-zA-Z0-9]*$/ },
+          :ParameterNumberCheck            => { :parameter_count => 3 }
+        }
+      
+        attr_writer :config
+      
+        def initialize(*checks)
+          @config = DEFAULT_CONFIG
+          @checks = checks unless checks.empty?
+          @parser = Parser.new
+        end
+      
+        def check(filename, content)
+          @checks ||= load_checks
+          node = parse(filename, content)
+          node.accept(IteratorVisitor.new(CheckingVisitor.new(@checks))) if node
+        end
+
+        def check_content(content)
+          check("dummy-file.rb", content)
+        end
+  
+        def check_file(filename)
+          check(filename, File.read(filename))
+        end
+  
+        def errors
+          @checks ||= []
+          all_errors = @checks.collect {|check| check.errors}
+          all_errors.flatten
+        end
+      
+        private
+      
+          def parse(filename, content)
+            begin
+              @parser.parse(content, filename)
+            rescue Exception => e
+              puts "#{filename} looks like it's not a valid Ruby file. Skipping..." if ENV["ROODI_DEBUG"]
+              nil
+            end
+          end
+        
+          def load_checks
+            check_objects = []
+            DEFAULT_CONFIG.each_pair do |key, value| 
+              klass = eval("Simplabs::Excellent::Checks::#{key.to_s}")
+              check_objects << (value.empty? ? klass.new : klass.new(value))
+            end
+            check_objects
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/core/parser.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'ruby_parser'
+require 'facets'
+
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      class Parser
+
+        def parse(content, filename)
+          silence_stream(STDERR) do 
+            return silent_parse(content, filename)
+          end
+        end
+
+        private
+
+          def silent_parse(content, filename)
+            @parser ||= RubyParser.new
+            sexp = @parser.parse(content, filename)
+            sexp
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/core/visitable_sexp.rb

@@ -0,0 +1,31 @@
+module Simplabs
+
+  module Excellent
+
+    module Core
+
+      module VisitableSexp
+
+        def accept(visitor)
+          visitor.visit(self)
+        end
+      
+        def node_type
+          first
+        end
+      
+        def children
+          sexp_body.select { |child| child.is_a?(VisitableSexp) }
+        end
+      
+        def is_language_node?
+          first.class == Symbol
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/checks/abc_metric_method_check_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::AbcMetricMethodCheck.new({ :threshold => 0 }))
+  end
+
+  describe '#evaluate' do
+
+    describe 'when processing assignments' do
+
+      ['=', '*=', '/=', '%=', '+=', '<<=', '>>=', '&=', '|=', '^=', '-=', '**='].each do |assignment|
+
+        it "should find #{assignment}" do
+          content = <<-END
+            def method_name
+              foo #{assignment} 1
+            end
+          END
+
+          verify_content_score(content, 1, 0, 0)
+        end
+
+      end
+
+    end
+
+    describe 'when processing branches' do
+
+      it 'should find a virtual method call' do
+        content = <<-END
+          def method_name
+            call_foo
+          end
+        END
+
+        verify_content_score(content, 0, 1, 0)
+      end
+
+      it 'should find an explicit method call' do
+        content = <<-END
+          def method_name
+            @object.call_foo
+          end
+        END
+
+        verify_content_score(content, 0, 1, 0)
+      end
+
+      it 'should exclude a condition' do
+        content = <<-END
+          def method_name
+            @object.call_foo < 10
+          end
+        END
+
+        verify_content_score(content, 0, 1, 1)
+      end
+
+    end
+
+    describe 'when processing conditions' do
+
+      ['==', '!=', '<=', '>=', '<', '>', '<=>', '=~'].each do |conditional|
+
+        it "should find #{conditional}" do
+          content = <<-END
+            def method_name
+              @foo #{conditional} @bar
+            end
+          END
+
+          verify_content_score(content, 0, 0, 1)
+        end
+
+      end 
+
+    end
+
+  end
+
+  def verify_content_score(content, a, b, c)
+    score = Math.sqrt(a*a + b*b + c*c)
+    @excellent.check_content(content)
+    errors = @excellent.errors
+
+    errors.should_not be_empty
+    errors[0].info[:method].should == :method_name
+    errors[0].info[:score].should  == score
+    errors[0].message.should       == "Method method_name has abc score of #{score}."
+  end
+
+end

data/spec/checks/assignment_in_conditional_check_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::AssignmentInConditionalCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept an assignment before an if clause' do
+      content = <<-END
+        count = count += 1 if some_condition
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should reject an assignment inside an if clause' do
+      content = <<-END
+        call_foo if bar = bam
+      END
+
+      verify_error_found(content)
+    end
+
+    it 'should reject an assignment inside an unless clause' do
+      content = <<-END
+        call_foo unless bar = bam
+      END
+
+      verify_error_found(content)
+    end
+
+    it 'should reject an assignment inside a while clause' do
+      content = <<-END
+        call_foo while bar = bam
+      END
+
+      verify_error_found(content)
+    end
+
+    it 'should reject an assignment inside an until clause' do
+      content = <<-END
+        call_foo until bar = bam
+      END
+
+      verify_error_found(content)
+    end
+
+    it 'should reject an assignment inside a ternary operator check clause' do
+      content = <<-END
+        call_foo (bar = bam) ? baz : bad
+      END
+
+      #RubyParser sets line number 2 here
+      verify_error_found(content, 2)
+    end
+
+  end
+
+  def verify_error_found(content, line_number = nil)
+    @excellent.check_content(content)
+    errors = @excellent.errors
+
+    errors.should_not be_empty
+    errors[0].info.should        == {}
+    errors[0].line_number.should == (line_number || 1)
+    errors[0].message.should     == 'Assignment in condition.'
+  end
+
+end

data/spec/checks/case_missing_else_check_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::CaseMissingElseCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::CaseMissingElseCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept case statements that do have an else clause' do
+      content = <<-END
+        case foo
+          when "bar": "ok"
+          else "good"
+          end
+      END
+      @excellent.check_content(content)
+      errors = @excellent.errors
+
+      errors.should be_empty
+    end
+
+    it 'should reject case statements that do not have an else clause' do
+      content = <<-END
+        case foo
+          when "bar": "ok"
+          when "bar": "bad"
+          end
+      END
+      @excellent.check_content(content)
+      errors = @excellent.errors
+
+      errors.should_not be_empty
+      errors[0].info.should        == {}
+      errors[0].line_number.should == 2
+      errors[0].message.should     == 'Case statement is missing else clause.'
+    end
+
+  end
+
+end

data/spec/checks/class_line_count_check_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::ClassLineCountCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::ClassLineCountCheck.new({ :threshold => 1 }))
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept classes with less lines than the threshold' do
+      content = <<-END
+        class ZeroLineClass; end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should accept classes with the same number of lines as the threshold' do
+      content = <<-END
+        Class OneLineClass
+          @foo = 1
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should reject classes with more lines than the threshold' do
+      content = <<-END
+        class TwoLineClass
+          @foo = 1
+          @bar = 2
+        end
+      END
+      @excellent.check_content(content)
+      errors = @excellent.errors
+
+      errors.should_not be_empty
+      errors[0].info.should        == { :class => :TwoLineClass, :count => 2 }
+      errors[0].line_number.should == 1
+      errors[0].message.should     == 'Class TwoLineClass has 2 lines.'
+    end
+
+  end
+
+end