skeptic 0.0.0 → 0.0.1

data/Rakefile

@@ -22,6 +22,9 @@ Jeweler::Tasks.new do |gem|
   gem.email = "stefan.kanev@gmail.com"
   gem.authors = ["Stefan Kanev"]
   # dependencies defined in Gemfile
+  gem.files.exclude 'spec/**/*.rb'
+  gem.files.exclude 'features/**/*.rb'
+  gem.files.exclude 'tmp'
 end
 Jeweler::RubygemsDotOrgTasks.new
 
@@ -41,7 +44,7 @@ Cucumber::Rake::Task.new(:features)
 
 task :default => :spec
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/bin/skeptic

@@ -3,21 +3,31 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'skeptic'
 require 'trollop'
 
-opts = Trollop::options do
-  opt :lines_per_method,  'Maximum number of lines per method', type: :int
-  opt :max_nesting_depth, 'Maximum nesting depth', type: :int
-  opt :methods_per_class, 'Maximum number of methods per class', type: :int
-  opt :no_semicolons,     'Complain about semicolons', type: :boolean
-end
-code = File.read ARGV[0]
+parser = Trollop::Parser.new do
+  banner <<BANNER
+Points out annoying things in your Ruby code. Just run with:
 
-critic = Skeptic::Critic.new
+  skeptic [options] <path_to_file>
 
-critic.no_semicolons     = opts[:no_semicolons]
-critic.max_nesting_depth = opts[:max_nesting_depth]
-critic.methods_per_class = opts[:methods_per_class]
-critic.lines_per_method  = opts[:lines_per_method]
+where [options] are:
+BANNER
+  Skeptic::Rules.table.each_rule do |klass, slug, option_type, description|
+    opt slug, description, type: option_type
+  end
+  opt :file, 'Path to file to analyze', type: :string
+end
+
+opts = Trollop::with_standard_exception_handling parser do
+  parsed = parser.parse ARGV
+  parsed[:file] ||= ARGV.shift unless parsed[:file_given]
+  raise Trollop::HelpNeeded unless parsed[:file]
+  raise Trollop::CommandlineError, "excessive arguments: #{ARGV.join(' ')}" unless ARGV.empty?
+  raise Trollop::CommandlineError, "file does not exist: #{parsed[:file]}" unless File.exist? parsed[:file]
+  parsed
+end
 
+code = File.read opts[:file]
+critic = Skeptic::Critic.new opts.select { |key, value| Skeptic::Rules.table.slugs.include? key }
 critic.criticize code
 
 if critic.criticism.empty?

data/features/skeptic.feature

@@ -74,3 +74,28 @@ Feature: Running skeptic
       Number of methods per class (1)
       * Foo has 2 methods: #bar, #baz
       """
+
+  Scenario: Limiting line length
+    Given a file named "input.rb" with:
+      """
+      short line
+      longer line
+      """
+    When I run `skeptic --line-length 10 input.rb`
+    Then it should fail with:
+      """
+      Line length (10)
+      * Line 2 is too long: 11 columns
+      """
+
+  Scenario: Checking the syntax
+    Given a file named "input.rb" with:
+      """
+      unexpected end
+      """
+    When I run `skeptic --check-syntax input.rb`
+    Then it should fail with:
+      """
+      Syntax check
+      * Invalid syntax:
+      """

data/lib/skeptic/critic.rb

@@ -1,14 +1,15 @@
 module Skeptic
   class Critic
-    attr_accessor :lines_per_method
-    attr_accessor :max_nesting_depth
-    attr_accessor :methods_per_class
-    attr_accessor :no_semicolons
+    attr_accessor *Rules.table.slugs
 
     attr_reader :criticism
 
-    def initialize
+    def initialize(options = {})
       @criticism = []
+
+      options.each do |key, value|
+        send "#{key}=", value
+      end
     end
 
     def criticize(code)
@@ -16,16 +17,11 @@ module Skeptic
       @tokens = Ripper.lex(code)
       @sexp   = Ripper.sexp(code)
 
-      rules = {
-        Rules::LinesPerMethod  => lines_per_method,
-        Rules::MaxNestingDepth => max_nesting_depth,
-        Rules::MethodsPerClass => methods_per_class,
-        Rules::NoSemicolons    => no_semicolons,
-      }
+      Rules.table.each_rule do |rule_class, slug, option|
+        next unless send(slug)
 
-      rules.reject { |rule_type, option| option.nil? }.each do |rule_type, option|
-        rule = rule_type.new(option)
-        rule.apply_to @tokens, @sexp
+        rule = rule_class.new send(slug)
+        rule.apply_to @code, @tokens, @sexp
 
         rule.violations.each do |violation|
           @criticism << [violation, rule.name]

data/lib/skeptic/rule_table.rb

@@ -0,0 +1,40 @@
+module Skeptic
+  class RuleTable
+    def initialize
+      @rules = {}
+    end
+
+    def rules
+      @rules.keys
+    end
+
+    def register(klass, option_type)
+      @rules[klass] = option_type
+    end
+
+    def slugs
+      @rules.keys.map { |klass| slug_for klass }
+    end
+
+    def each_rule
+      @rules.each do |klass, option_type|
+        yield klass, slug_for(klass), option_type, description_for(klass)
+      end
+    end
+
+    private
+
+    def description_for(klass)
+      klass.const_get(:DESCRIPTION)
+    end
+
+    def slug_for(klass)
+      klass
+        .name
+        .gsub(/.*::/, '')
+        .gsub(/([a-z])([A-Z])/, '\1_\2')
+        .downcase
+        .to_sym
+    end
+  end
+end

data/lib/skeptic/rules/check_syntax.rb

@@ -0,0 +1,27 @@
+require 'open3'
+
+module Skeptic
+  module Rules
+    class CheckSyntax
+      DESCRIPTION = 'Check the syntax'
+
+      def initialize(enabled = false)
+        @errors = []
+      end
+
+      def apply_to(code, tokens, sexp)
+        output, error, status = Open3.capture3 'ruby -c', stdin_data: code
+        @errors << "Invalid syntax:\n#{error.gsub(/^/m, '  ')}" unless output.chomp == 'Syntax OK'
+        self
+      end
+
+      def violations
+        @errors
+      end
+
+      def name
+        'Syntax check'
+      end
+    end
+  end
+end

data/lib/skeptic/rules/line_length.rb

@@ -0,0 +1,31 @@
+module Skeptic
+  module Rules
+    class LineLength
+      DESCRIPTION = 'Limit the line length'
+
+      attr_reader :line_lengths
+
+      def initialize(limit)
+        @limit = limit
+        @line_lengths = {}
+      end
+
+      def apply_to(code, tokens, sexp)
+        code.lines.each_with_index do |line, index|
+          @line_lengths[index + 1] = line.chomp.length
+        end
+        self
+      end
+
+      def violations
+        @line_lengths.select { |line, length| length > @limit }.map do |line, length|
+          "Line #{line} is too long: #{length} columns"
+        end
+      end
+
+      def name
+        "Line length (#@limit)"
+      end
+    end
+  end
+end

data/lib/skeptic/rules/lines_per_method.rb

@@ -1,6 +1,8 @@
 module Skeptic
   module Rules
     class LinesPerMethod
+      DESCRIPTION = 'Limit the number of lines in each method'
+
       include SexpVisitor
 
       def initialize(limit = nil)
@@ -9,7 +11,7 @@ module Skeptic
         @limit = limit
       end
 
-      def apply_to(tokens, sexp)
+      def apply_to(code, tokens, sexp)
         visit sexp
         self
       end

data/lib/skeptic/rules/max_nesting_depth.rb

@@ -1,6 +1,8 @@
 module Skeptic
   module Rules
     class MaxNestingDepth
+      DESCRIPTION = 'Limit the maximum nesting depth'
+
       include SexpVisitor
 
       def initialize(limit = nil)
@@ -9,7 +11,7 @@ module Skeptic
         @limit  = limit
       end
 
-      def apply_to(tokens, sexp)
+      def apply_to(code, tokens, sexp)
         visit sexp
         self
       end
@@ -62,6 +64,14 @@ module Skeptic
         end
       end
 
+      on :ifop do |condition, true_branch, false_branch|
+        with scope.push(:ternary_if) do
+          visit condition
+          visit true_branch
+          visit false_branch
+        end
+      end
+
       on :while, :while_mod, :until, :until_mod do |condition, body|
         key = sexp_type.to_s.gsub(/_mod$/, '').to_sym
 

data/lib/skeptic/rules/methods_per_class.rb

@@ -1,6 +1,8 @@
 module Skeptic
   module Rules
     class MethodsPerClass
+      DESCRIPTION = 'Limit the number of methods per class'
+
       include SexpVisitor
 
       def initialize(limit)
@@ -8,7 +10,7 @@ module Skeptic
         @limit   = limit
       end
 
-      def apply_to(tokens, tree)
+      def apply_to(code, tokens, tree)
         visit tree
         self
       end

data/lib/skeptic/rules/no_semicolons.rb

@@ -1,11 +1,13 @@
 module Skeptic
   module Rules
     class NoSemicolons
+      DESCRIPTION = 'Do not allow semicolons as statement separators'
+
       def initialize(enabled = false)
         @enabled = enabled
       end
 
-      def apply_to(tokens, sexp)
+      def apply_to(code, tokens, sexp)
         @locations = tokens.
           select { |location, type, token| token == ';' and type == :on_semicolon }.
           map { |location, type, token| location }

data/lib/skeptic/rules.rb

@@ -0,0 +1,14 @@
+module Skeptic
+  module Rules
+    def self.table
+      @rule_table ||= RuleTable.new
+    end
+
+    table.register CheckSyntax, :boolean
+    table.register LineLength, :int
+    table.register LinesPerMethod, :int
+    table.register MaxNestingDepth, :int
+    table.register MethodsPerClass, :int
+    table.register NoSemicolons, :boolean
+  end
+end

data/lib/skeptic.rb

@@ -4,9 +4,13 @@ require 'skeptic/environment'
 require 'skeptic/scope'
 require 'skeptic/sexp_visitor'
 
+require 'skeptic/rules/check_syntax'
 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/rules/line_length'
 
+require 'skeptic/rule_table'
+require 'skeptic/rules'
 require 'skeptic/critic'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skeptic
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-26 00:00:00.000000000Z
+date: 2011-10-28 00:00:00.000000000 +03:00
+default_executable: skeptic
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
-  requirement: &25894860 !ruby/object:Gem::Requirement
+  requirement: &2157956920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +22,10 @@ dependencies:
         version: 1.16.2
   type: :runtime
   prerelease: false
-  version_requirements: *25894860
+  version_requirements: *2157956920
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &25893680 !ruby/object:Gem::Requirement
+  requirement: &2157956340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *25893680
+  version_requirements: *2157956340
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &25892440 !ruby/object:Gem::Requirement
+  requirement: &2157955800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *25892440
+  version_requirements: *2157955800
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &25891280 !ruby/object:Gem::Requirement
+  requirement: &2157955200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +55,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *25891280
+  version_requirements: *2157955200
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &25890280 !ruby/object:Gem::Requirement
+  requirement: &2157954600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +66,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *25890280
+  version_requirements: *2157954600
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &25889520 !ruby/object:Gem::Requirement
+  requirement: &2157949640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +77,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *25889520
+  version_requirements: *2157949640
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &25888560 !ruby/object:Gem::Requirement
+  requirement: &2157949120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,7 +88,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *25888560
+  version_requirements: *2157949120
 description: An experimental, half-assed, bug-ridden and highly opinionated code analyzer.
 email: stefan.kanev@gmail.com
 executables:
@@ -107,26 +108,20 @@ files:
 - VERSION
 - bin/skeptic
 - features/skeptic.feature
-- features/step_definitions/skeptic_steps.rb
-- features/support/aruba.rb
-- features/support/env.rb
 - lib/skeptic.rb
 - lib/skeptic/critic.rb
 - lib/skeptic/environment.rb
+- lib/skeptic/rule_table.rb
+- lib/skeptic/rules.rb
+- lib/skeptic/rules/check_syntax.rb
+- lib/skeptic/rules/line_length.rb
 - lib/skeptic/rules/lines_per_method.rb
 - lib/skeptic/rules/max_nesting_depth.rb
 - lib/skeptic/rules/methods_per_class.rb
 - lib/skeptic/rules/no_semicolons.rb
 - lib/skeptic/scope.rb
 - lib/skeptic/sexp_visitor.rb
-- spec/skeptic/critic_spec.rb
-- spec/skeptic/environment_spec.rb
-- spec/skeptic/rules/lines_per_method_spec.rb
-- spec/skeptic/rules/max_nesting_depth_spec.rb
-- spec/skeptic/rules/methods_per_class_spec.rb
-- spec/skeptic/rules/no_semicolons_spec.rb
-- spec/skeptic/scope_spec.rb
-- spec/spec_helper.rb
+has_rdoc: true
 homepage: http://github.com/skanev/skeptic
 licenses:
 - MIT
@@ -142,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2839916521790912268
+      hash: -794478687402394833
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -151,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Skeptic points out annoying things in your code

data/features/support/aruba.rb

@@ -1 +0,0 @@
-require 'aruba/cucumber'

data/features/support/env.rb

@@ -1,13 +0,0 @@
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'skeptic'
-
-require 'rspec/expectations'

data/spec/skeptic/critic_spec.rb

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

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

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

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

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

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

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

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