skeptic 0.0.0

data/lib/skeptic/sexp_visitor.rb

@@ -0,0 +1,65 @@
+module Skeptic
+  module SexpVisitor
+    def self.included(receiver)
+      receiver.send :include, InstanceMethods
+      receiver.extend ClassMethods
+    end
+
+    module ClassMethods
+      def handlers
+        @handlers ||= {}
+      end
+
+      def on(*types, &block)
+        types.each do |type|
+          handlers[type] = block
+        end
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      def visit(sexp)
+        if Symbol === sexp[0] and self.class.handlers.has_key? sexp[0]
+          type, *args = *sexp
+          handler = self.class.handlers[type]
+
+          with_sexp_type(type) { instance_exec *args, &handler }
+        else
+          range = sexp[0].kind_of?(Symbol) ? 1..-1 : 0..-1
+
+          sexp[range].each do |subtree|
+            visit subtree if subtree.kind_of?(Array) and not subtree[0].kind_of?(Fixnum)
+          end
+        end
+      end
+
+      def env
+        @env ||= Environment.new
+      end
+
+      def with_sexp_type(type)
+        @current_sexp_type, old_sexp_type = type, @current_sexp_type
+        yield
+        @current_sexp_type = old_sexp_type
+      end
+
+      def sexp_type
+        @current_sexp_type
+      end
+
+      def extract_name(tree)
+        type, first, second = *tree
+        case type
+          when :const_path_ref then "#{extract_name(first)}::#{extract_name(second)}"
+          when :const_ref then extract_name(first)
+          when :var_ref then extract_name(first)
+          when :@const then first
+          when :@ident then first
+          else '<unknown>'
+        end
+      end
+    end
+  end
+end

data/lib/skeptic.rb

@@ -0,0 +1,12 @@
+require 'ripper'
+
+require 'skeptic/environment'
+require 'skeptic/scope'
+require 'skeptic/sexp_visitor'
+
+require 'skeptic/rules/max_nesting_depth'
+require 'skeptic/rules/methods_per_class'
+require 'skeptic/rules/lines_per_method'
+require 'skeptic/rules/no_semicolons'
+
+require 'skeptic/critic'

data/spec/skeptic/critic_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Skeptic
+  describe Critic do
+    let(:critic) { Critic.new }
+
+    it "can locate semicolons in the code" do
+      criticize 'foo; bar', no_semicolons: true
+
+      expect_criticism 'You have a semicolon at line 1, column 3', 'No semicolons as expression separators'
+    end
+
+    it "can locate deep levels of nesting" do
+      criticize <<-RUBY, max_nesting_depth: 1
+        class Foo
+          def bar
+            while true
+              if false
+                really?
+              end
+            end
+          end
+        end
+      RUBY
+
+      expect_criticism 'Foo#bar has 2 levels of nesting: while > if', 'Maximum nesting depth (1)'
+    end
+
+    it "can locate classes with too many methods" do
+      criticize <<-RUBY, methods_per_class: 1
+        class Foo
+          def bar; end
+          def baz; end
+        end
+      RUBY
+
+      expect_criticism 'Foo has 2 methods: #bar, #baz', 'Number of methods per class (1)'
+    end
+
+    it "can locate methods that are too long" do
+      criticize <<-RUBY, lines_per_method: 1
+        class Foo
+          def bar
+            one
+            two
+            three
+          end
+        end
+      RUBY
+
+      expect_criticism 'Foo#bar is 3 lines long', 'Number of lines per method (1)'
+    end
+
+    def criticize(code, options)
+      options.each do |key, value|
+        critic.send "#{key}=", value
+      end
+
+      critic.criticize code
+    end
+
+    def expect_criticism(message, type)
+      critic.criticism.should include [message, type]
+    end
+  end
+end

data/spec/skeptic/environment_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module Skeptic
+  describe Environment do
+    let(:env) { Environment.new }
+
+    it "maps names to objects" do
+      env[:foo] = 42
+      env[:foo].should eq 42
+    end
+
+    it "returns nil for names that are not set" do
+      env[:foo].should be_nil
+    end
+
+    it "allows environments to be extender" do
+      env.push foo: 2
+      env[:foo].should eq 2
+    end
+
+    it "allows environments to be unextended" do
+      env[:foo] = 1
+      env.push foo: 2
+      env.pop
+      env[:foo].should eq 1
+    end
+
+    it "looks up undefined names in the closure" do
+      env[:foo] = 1
+      env.push
+      env[:foo].should eq 1
+    end
+
+    it "can be extended for a block" do
+      executed_block = false
+
+      env[:foo] = 1
+      env.scoped do
+        env[:foo] = 2
+        env[:foo].should eq 2
+        executed_block = true
+      end
+
+      executed_block.should be_true
+      env[:foo].should eq 1
+    end
+  end
+end

data/spec/skeptic/rules/lines_per_method_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Skeptic
+  module Rules
+    describe LinesPerMethod do
+      describe "calculating method size" do
+        it "can count the size of a method" do
+          code = <<-RUBY
+            class Foo
+              def bar
+                first
+                second
+              end
+            end
+          RUBY
+
+          analyze(code).size_of('Foo#bar').should eq 2
+        end
+
+        it "does not count empty lines" do
+          expect_line_count 2, <<-RUBY
+            foo
+
+            bar
+          RUBY
+        end
+
+        it "does not count lines containing one end" do
+          expect_line_count 2, <<-RUBY
+            if foo
+              bar
+            end
+          RUBY
+        end
+      end
+
+      describe "reporting" do
+        it "can tell which methods are too long" do
+          analyzer = analyze 1, <<-RUBY
+            class Foo
+              def bar
+                one
+                two
+                three
+              end
+            end
+          RUBY
+
+          analyzer.violations.should include 'Foo#bar is 3 lines long'
+        end
+
+        it "reports under 'Number of lines per method'" do
+          LinesPerMethod.new(2).name.should eq 'Number of lines per method (2)'
+        end
+      end
+
+      def expect_line_count(count, code)
+        code = "class Foo\ndef bar\n#{code}\nend\nend"
+        analyze(code).size_of('Foo#bar').should eq count
+      end
+
+      def analyze(limit = nil, code)
+        LinesPerMethod.new(limit).apply_to nil, Ripper.sexp(code)
+      end
+    end
+  end
+end

data/spec/skeptic/rules/max_nesting_depth_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+module Skeptic
+  module Rules
+    describe MaxNestingDepth do
+      describe "structure analysis" do
+        it "counts all conditional forms as a level of nesting" do
+          expect_deepest_nesting :if, 'if condition?; action; end'
+          expect_deepest_nesting :if, 'if condition? then action end'
+          expect_deepest_nesting :if, 'action if condition?'
+          expect_deepest_nesting :unless, 'action unless condition?'
+          expect_deepest_nesting :unless, 'unless condition?; action; end'
+          expect_deepest_nesting :unless, 'unless condition? then action end'
+          expect_deepest_nesting :if, :if, 'a if b? if c?'
+        end
+
+        it "counts else blocks as a level of nesting" do
+          expect_deepest_nesting :if, :unless, 'if a?; else; foo unless b? end'
+          expect_deepest_nesting :if, :unless, 'if a?; elsif? b?; else; foo unless c? end'
+          expect_deepest_nesting :unless, :if, 'unless a?; else; foo if b? end'
+        end
+
+        it "counts elsif blocks as a level of nesting" do
+          expect_deepest_nesting :if, :unless, 'if a?; elsif b?; foo unless c?; end'
+          expect_deepest_nesting :if, :unless, 'if a?; elsif b?; foo unless c?; else; end'
+        end
+
+        it "counts unbound loops as a level of nesting" do
+          expect_deepest_nesting :while, :if, 'while a?; b if c? end'
+          expect_deepest_nesting :while, :if, '(a if b?) while c?'
+          expect_deepest_nesting :until, :if, 'until a?; b if c? end'
+          expect_deepest_nesting :until, :if, '(a if b?) until c?'
+        end
+
+        it "counts blocks as a level of nesting" do
+          expect_deepest_nesting :iter, :if, 'a { b if c? }'
+          expect_deepest_nesting :iter, :if, 'a(1) { b if c? }'
+          expect_deepest_nesting :iter, :if, 'a do; b if c?; end'
+          expect_deepest_nesting :iter, :if, 'a(1) do; b if c?; end'
+
+          expect_deepest_nesting :iter, :if, 'loop { a if b }'
+        end
+
+        it "counts lambdas as a level of nesting" do
+          expect_deepest_nesting :iter, :if, 'lambda { a if b }'
+          expect_deepest_nesting :iter, :if, 'Proc.new { a if b }'
+          expect_deepest_nesting :lambda, :if, '-> { a if b }'
+        end
+
+        it "counts for loops as a level of nesting" do
+          expect_deepest_nesting :for, :if, 'for a in b; c if d; end'
+        end
+
+        it "counts case statements as a level of nesting" do
+          expect_deepest_nesting :case, :if, 'case a; when b; c if d?; end'
+          expect_deepest_nesting :case, :if, 'case a; when b; when c; d if e?; end'
+          expect_deepest_nesting :case, :if, 'case a; when b; else; d if e?; end'
+        end
+
+        it "counts begin blocks as a level of nesting" do
+          expect_deepest_nesting :begin, :if, 'begin; a if b; end'
+        end
+
+        it "does not count the method invocation as a block" do
+          expect_a_nesting :if, 'a((b if c)) { d }'
+          expect_a_nesting :iter, :if, 'a.b { c if d? }.e { g }'
+          expect_a_nesting :iter, :unless, 'a.b { c unless d? }.c { }'
+        end
+
+        it "does not count the if condition as a level of nesting" do
+          expect_a_nesting :iter, 'a if b { c }'
+        end
+      end
+
+      describe "nesting location" do
+        it "recognizes top-level code" do
+          expect_scope nil, nil, :if, 'a if b'
+        end
+
+        it "recognizes class definitions" do
+          expect_scope 'A', nil, :if, 'class A; a if b; end'
+          expect_scope 'A::B', nil, :if, 'class A::B; a if b; end'
+        end
+
+        it "recognizes method definitions" do
+          expect_scope nil, 'a', :if, 'def a; b if c; end'
+          expect_scope 'A', 'b', :if, 'class A; def b; c if d; end; end'
+        end
+      end
+
+      describe "reporting" do
+        it "can report methods that contain a deep level of nesting" do
+          analyzer = analyze 1, <<-RUBY
+            class Foo
+              def bar
+                while true
+                  if false
+                    really?
+                  end
+                end
+              end
+            end
+          RUBY
+
+          analyzer.violations.should include 'Foo#bar has 2 levels of nesting: while > if'
+        end
+
+        it "reports under 'Maximum nesting depth'" do
+          MaxNestingDepth.new(2).name.should eq 'Maximum nesting depth (2)'
+        end
+      end
+
+      def nestings(code)
+        analyze(code).nestings
+      end
+
+      def expect_scope(class_name, method_name, *levels, code)
+        analyze(code).nestings.should include Scope.new(class_name, method_name, levels)
+      end
+
+      def expect_a_nesting(*levels, code)
+        analyze(code).nestings.should include Scope.new(nil, nil, levels)
+      end
+
+      def expect_deepest_nesting(*levels, code)
+        analyze(code).nestings.max_by(&:depth).should eq Scope.new(nil, nil, levels)
+      end
+
+      def analyze(limit = nil, code)
+        MaxNestingDepth.new(limit).apply_to nil, Ripper.sexp(code)
+      end
+    end
+  end
+end

data/spec/skeptic/rules/methods_per_class_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module Skeptic
+  module Rules
+    describe MethodsPerClass do
+      describe "counting methods" do
+        it "counts methods defined in classes" do
+          expect_method_count 'Foo', 2, <<-RUBY
+            class Foo
+              def bar; end
+              def baz; end
+            end
+          RUBY
+        end
+
+        it "counts methods defined in modules" do
+          expect_method_count 'Foo', 2, <<-RUBY
+            module Foo
+              def bar; end
+              def baz; end
+            end
+          RUBY
+        end
+
+        it "counts method defined when the class is reopened" do
+          expect_method_count 'Foo', 2, <<-RUBY
+            class Foo; def bar; end; end
+            class Foo; def baz; end; end
+          RUBY
+        end
+
+        it "counts redefining the method as a new method" do
+          expect_method_count 'Foo', 2, <<-RUBY
+            class Foo
+              def bar; end
+              def bar; end
+            end
+          RUBY
+        end
+
+        it "works with multiple classes" do
+          counter = analyze <<-RUBY
+            class Foo; def name; end; end
+            class Bar; def name; end; end
+          RUBY
+
+          counter.methods_in('Foo').should eq 1
+          counter.methods_in('Bar').should eq 1
+        end
+
+        it "recognizes qualified module names" do
+          expect_method_count 'Foo::Bar', 1, <<-RUBY
+            class Foo::Bar; def baz; end; end
+          RUBY
+        end
+
+        it "recognizes modules nested under other modules" do
+          expect_method_count 'Foo::Bar', 1, <<-RUBY
+            class Foo; module Bar; def baz; end; end; end
+          RUBY
+        end
+      end
+
+      describe "reporting" do
+        it "reports classes, violating the rule" do
+          analyzer = analyze 1, <<-RUBY
+            class Foo
+              def bar; end
+              def baz; end
+            end
+          RUBY
+
+          analyzer.violations.should include 'Foo has 2 methods: #bar, #baz'
+        end
+
+        it "reports under 'Number of methods per class'" do
+          MethodsPerClass.new(42).name.should eq 'Number of methods per class (42)'
+        end
+      end
+
+      def analyze(limit = nil, code)
+        MethodsPerClass.new(limit).apply_to nil, Ripper.sexp(code)
+      end
+
+      def expect_method_count(class_name, count, code)
+        analyze(code).methods_in(class_name).should eq count
+      end
+    end
+  end
+end

data/spec/skeptic/rules/no_semicolons_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Skeptic
+  module Rules
+    describe NoSemicolons do
+      describe "detecting semicolons" do
+        it "complains if it finds a semicolon in the code" do
+          expect_complaint 'foo; bar'
+          expect_complaint 'this; that; other'
+          expect_complaint '"#{foo;bar}"'
+        end
+
+        it "does not complain for semicolons in literals" do
+          expect_fine_and_dandy '"foo;"'
+          expect_fine_and_dandy '";"'
+          expect_fine_and_dandy '/;/'
+        end
+
+        it "can tell the locations of the semicolons" do
+          analyze("foo;\n;bar").semicolon_locations.should =~ [[1, 3], [2, 0]]
+        end
+      end
+
+      describe "reporting" do
+        it "points out file locations with semicolons" do
+          analyzer = analyze 'foo; bar'
+
+          analyzer.violations.should include 'You have a semicolon at line 1, column 3'
+        end
+
+        it "reports under 'No semicolons'" do
+          NoSemicolons.new(true).name.should eq 'No semicolons as expression separators'
+        end
+      end
+
+      def expect_fine_and_dandy(code)
+        analyze(code).semicolon_locations.should be_empty
+      end
+
+      def expect_complaint(code)
+        analyze(code).semicolon_locations.should_not be_empty
+      end
+
+      def analyze(code)
+        NoSemicolons.new(true).apply_to Ripper.lex(code), nil
+      end
+    end
+  end
+end

data/spec/skeptic/scope_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Skeptic
+  describe Scope do
+    it "contains levels of nesting" do
+      Scope.new(nil, nil, [:for, :if]).levels.should eq [:for, :if]
+      Scope.new(nil, nil, []).levels.should eq []
+      Scope.new.levels.should eq []
+    end
+
+    it "can be compared to another scope" do
+      Scope.new(nil, nil, [:for, :if]).should eq Scope.new(nil, nil, [:for, :if])
+      Scope.new(nil, nil, []).should_not eq Scope.new(nil, nil, [:if])
+      Scope.new('Bar', nil).should_not eq Scope.new('Foo', nil)
+      Scope.new(nil, 'bar').should_not eq Scope.new(nil, 'foo')
+    end
+
+    it "can be extended and unextended" do
+      Scope.new.push(:if).should eq Scope.new(nil, nil, [:if])
+      Scope.new(nil, nil, [:for, :if]).pop.should eq Scope.new(nil, nil, [:for])
+
+      Scope.new.in_class('Foo').should eq Scope.new('Foo')
+      Scope.new.in_method('bar').should eq Scope.new(nil, 'bar')
+    end
+
+    it "can tell its depth" do
+      Scope.new(nil, nil, [:for]).depth.should eq 1
+      Scope.new(nil, nil, [:for, :if]).depth.should eq 2
+      Scope.new(nil, nil, [:for, :if, :if]).depth.should eq 3
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'skeptic'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end