scampi 0.1.1

data/lib/scampi/context.rb

@@ -0,0 +1,166 @@
+module Scampi
+  class Context
+    attr_reader :name, :block
+
+    def initialize(name, &block)
+      @name = name
+      @block = block
+      @items = []
+      @before = []
+      @after = []
+    end
+
+    # Phase 1: evaluate block to discover specs and children.
+    # Nothing is executed — it and describe just queue.
+    def register
+      tap do
+        if name =~ RestrictContext
+          instance_eval(&block)
+        else
+          self
+        end
+      end
+    end
+
+    # Count total specs recursively.
+    def count
+      @items.sum { |item|
+        case item[0]
+        when :spec  then 1
+        when :child then item[1].count
+        else 0
+        end
+      }
+    end
+
+    # Phase 2: run all registered specs in order, emitting TAP subtests.
+    # +indent+ is the nesting depth (0 = inside a top-level describe).
+    # Returns true if all specs/children passed, false otherwise.
+    def execute(indent = 0)
+      prefix = "    " * indent
+      inner  = "    " * (indent + 1)
+
+      plan = @items.count { |item| item[0] == :spec || item[0] == :child }
+
+      puts "#{prefix}# Subtest: #{@name}"
+      puts "#{inner}1..#{plan}"
+
+      befores = []
+      afters  = []
+      local_n = 0
+      all_passed = true
+
+      @items.each { |item|
+        case item[0]
+        when :before
+          befores << item[1]
+        when :after
+          afters << item[1]
+        when :spec
+          Counter[:specifications] += 1
+          local_n += 1
+          passed = run_requirement(item[1], item[2], befores, afters, indent + 1, local_n)
+          all_passed = false  unless passed
+        when :child
+          local_n += 1
+          child_passed = item[1].execute(indent + 1)
+          if child_passed
+            puts "#{inner}#{"ok".green} #{local_n} - #{item[1].name}"
+          else
+            puts "#{inner}#{"not ok".red} #{local_n} - #{item[1].name}"
+          end
+          all_passed = false  unless child_passed
+        end
+      }
+
+      all_passed
+    end
+
+    def before(&block); @items << [:before, block]; @before << block; end
+    def after(&block);  @items << [:after, block];  @after  << block; end
+
+    def behaves_like(*names)
+      names.each { |name| instance_eval(&Shared[name]) }
+    end
+
+    def it(description, &block)
+      return  unless description =~ RestrictName
+      block ||= proc { should.flunk "not implemented" }
+      @items << [:spec, description, block]
+    end
+
+    def should(*args, &block)
+      if Counter[:depth] == 0
+        it('should ' + args.first, &block)
+      else
+        super(*args, &block)
+      end
+    end
+
+    def run_requirement(description, spec, befores, afters, indent = 0, local_n = 1)
+      Scampi.handle_requirement(description, indent, local_n) do
+        begin
+          Counter[:depth] += 1
+          rescued = false
+          begin
+            befores.each { |block| instance_eval(&block) }
+            prev_req = Counter[:requirements]
+            instance_eval(&spec)
+          rescue Object => e
+            rescued = true
+            raise e
+          ensure
+            if Counter[:requirements] == prev_req and not rescued
+              raise Error.new(:missing,
+                              "empty specification: #{@name} #{description}")
+            end
+            begin
+              afters.each { |block| instance_eval(&block) }
+            rescue Object => e
+              raise e  unless rescued
+            end
+          end
+        rescue SystemExit, Interrupt
+          raise
+        rescue Object => e
+          ErrorLog << "#{e.class}: #{e.message}\n"
+          e.backtrace.find_all { |line| line !~ /bin\/scampi|\/scampi\.rb:\d+/ }.
+            each_with_index { |line, i|
+            ErrorLog << "\t#{line}#{i==0 ? ": #@name - #{description}" : ""}\n"
+          }
+          ErrorLog << "\n"
+
+          if e.kind_of? Error
+            Counter[e.count_as] += 1
+            e.count_as.to_s.upcase
+          else
+            Counter[:errors] += 1
+            "ERROR: #{e.class}"
+          end
+        else
+          ""
+        ensure
+          Counter[:depth] -= 1
+        end
+      end
+    end
+
+    def describe(*args, &block)
+      context = Scampi::Context.new(args.join(' '), &block)
+      (parent_context = self).methods(false).each { |e|
+        (class << context; self; end).send(:define_method, e) { |*args2, &block2|
+          parent_context.send(e, *args2, &block2)
+        }
+      }
+      @before.each { |b| context.before(&b) }
+      @after.each  { |b| context.after(&b) }
+      context.register
+      @items << [:child, context]
+      context
+    end
+
+    def raise?(*args, &block) = block.raise?(*args)
+    def throw?(*args, &block) = block.throw?(*args)
+    def change?(&block) = lambda{}.change?(&block)
+  end
+end

data/lib/scampi/error.rb

@@ -0,0 +1,10 @@
+module Scampi
+  class Error < RuntimeError
+    attr_accessor :count_as
+
+    def initialize(count_as, message)
+      @count_as = count_as
+      super message
+    end
+  end
+end

data/lib/scampi/monkey_patches.rb

@@ -0,0 +1,61 @@
+class Object
+  def true?  = false
+  def false? = false
+end
+
+class TrueClass
+  def true? = true
+end
+
+class FalseClass
+  def false? = true
+end
+
+class Proc
+  def raise?(*exceptions)
+    call
+  rescue *(exceptions.empty? ? RuntimeError : exceptions) => e
+    e
+  else
+    false
+  end
+
+  def throw?(sym)
+    catch(sym) {
+      call
+      return false
+    }
+    return true
+  end
+
+  def change?
+    pre_result = yield
+    call
+    post_result = yield
+    pre_result != post_result
+  end
+end
+
+class Numeric
+  def close?(to, delta)
+    (to.to_f - self).abs <= delta.to_f  rescue false
+  end
+end
+
+class Object
+  def should(*args, &block)
+    Scampi::Should.new(self).be(*args, &block)
+  end
+end
+
+module Kernel
+  private
+
+  def describe(*args, &block)
+    Scampi.queue << Scampi::Context.new(args.join(' '), &block)
+  end
+
+  def shared(name, &block)
+    Scampi::Shared[name] = block
+  end
+end

data/lib/scampi/should.rb

@@ -0,0 +1,67 @@
+module Scampi
+  class Should
+    # Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
+    # kind_of?, nil?, respond_to?, tainted?
+    instance_methods.each { |name| undef_method name  if name =~ /\?|^\W+$/ }
+
+    def initialize(object)
+      @object = object
+      @negated = false
+    end
+
+    def not(*args, &block)
+      @negated = !@negated
+
+      if args.empty?
+        self
+      else
+        be(*args, &block)
+      end
+    end
+
+    def be(*args, &block)
+      if args.empty?
+        self
+      else
+        unless block_given?
+          block = args.shift
+        end
+        satisfy(*args, &block)
+      end
+    end
+
+    alias a  be
+    alias an be
+
+    def satisfy(description="", &block)
+      r = yield(@object)
+      if Scampi::Counter[:depth] > 0
+        Scampi::Counter[:requirements] += 1
+        raise Scampi::Error.new(:failed, description)  unless @negated ^ r
+        r
+      else
+        @negated ? !r : !!r
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      name = "#{name}?"  if name.to_s =~ /\w[^?]\z/
+
+      desc = @negated ? "not ".dup : "".dup
+      desc << @object.inspect << "." << name.to_s
+      desc << "(" << args.map{|x|x.inspect}.join(", ") << ") failed"
+
+      satisfy(desc) { |x| x.__send__(name, *args, &block) }
+    end
+
+    def equal(value) = self == value
+    def match(value) = self =~ value
+
+    def identical_to(value) = self.equal? value
+    alias same_as identical_to
+
+    def flunk(reason="Flunked")
+      raise Scampi::Error.new(:failed, reason)
+    end
+  end
+end

data/lib/scampi/version.rb

@@ -0,0 +1,5 @@
+module Scampi
+  VERSION = "0.1.1"
+end
+
+require_relative '../rubygems_plugin'

data/lib/scampi/version.rb.erb

@@ -0,0 +1,5 @@
+module Scampi
+  VERSION = "<%= version %>"
+end
+
+require_relative '../rubygems_plugin'

data/lib/scampi.rb

@@ -0,0 +1,97 @@
+# Scampi -- small RSpec clone with TAP output.
+#
+# Forked from Bacon by Christian Neukirchen.
+# "Truth will sooner come out from error than from confusion." ---Francis Bacon
+
+# Copyright (C) 2007, 2008, 2012 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Scampi is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+require_relative 'scampi/version'
+require 'colorize_extended'
+
+module Scampi
+  Counter = Hash.new(0)
+  ErrorLog = "".dup
+  Shared = Hash.new { |_, name|
+    raise NameError, "no such context: #{name.inspect}"
+  }
+
+  RestrictName    = //  unless defined? RestrictName
+  RestrictContext = //  unless defined? RestrictContext
+
+  Backtraces = true  unless defined? Backtraces
+
+  @queue = []
+  @ran = false
+
+  def self.queue
+    @queue
+  end
+
+  def self.run
+    return if @ran
+    @ran = true
+
+    # Register: evaluate all describe blocks to discover specs
+    @queue.each(&:register)
+
+    # TAP version + plan (one entry per top-level describe)
+    puts "TAP version 14"
+    puts "1..#{@queue.size}"
+
+    # Execute all specs as subtests
+    @queue.each_with_index do |context, i|
+      passed = context.execute(0)
+      n = i + 1
+      if passed
+        puts "#{"ok".green} #{n} - #{context.name}"
+      else
+        puts "#{"not ok".red} #{n} - #{context.name}"
+      end
+    end
+
+    # Summary comment
+    tests, assertions, failures, errors =
+      Counter.values_at(:specifications, :requirements, :failed, :errors)
+    puts "# #{tests} tests, #{assertions} assertions, #{failures} failures, #{errors} errors"
+  end
+
+  def self.summary_on_exit
+    return  if Counter[:installed_summary] > 0
+    @timer = Time.now
+    at_exit {
+      run
+      if $!
+        raise $!
+      elsif Counter[:errors] + Counter[:failed] > 0
+        exit 1
+      end
+    }
+    Counter[:installed_summary] += 1
+  end
+  class << self; alias summary_at_exit summary_on_exit; end
+
+  # TAP output
+
+  def self.handle_requirement(description, indent = 0, local_n = 1)
+    ErrorLog.replace ""
+    error = yield
+    prefix = "    " * indent
+    if error.empty?
+      puts "#{prefix}#{"ok".green} #{local_n} - #{description}"
+      true
+    else
+      puts "#{prefix}#{"not ok".red} #{local_n} - #{description}: #{error}"
+      puts ErrorLog.strip.gsub(/^/, "#{prefix}# ")  if Backtraces
+      false
+    end
+  end
+end
+
+require_relative 'scampi/error'
+require_relative 'scampi/context'
+require_relative 'scampi/should'
+require_relative 'scampi/monkey_patches'
+require_relative 'rubygems_plugin'

data/scampi.gemspec

@@ -0,0 +1,30 @@
+require_relative 'lib/scampi/version'
+
+Gem::Specification.new do |s|
+  s.name            = "scampi"
+  s.version         = Scampi::VERSION
+  s.platform        = Gem::Platform::RUBY
+  s.summary         = "a small RSpec clone with built-in TAP support"
+  s.license         = "MIT"
+
+  s.description = <<-EOF
+Scampi is a small RSpec clone weighing less than 350 LoC but
+nevertheless providing all essential features. Includes a
+TAP (Test Anything Protocol) harness and assertion library.
+
+http://github.com/general-intelligence-systems/scampi
+  EOF
+
+  s.files           = `git ls-files`.split("\n") - [".gitignore"]
+  s.bindir          = 'exe'
+  s.executables     = ['scampi']
+  s.require_path    = 'lib'
+  s.extra_rdoc_files = ['README.rdoc']
+  s.test_files      = []
+
+  s.add_dependency 'colorize-extended'
+
+  s.author          = 'Nathan K'
+  s.email           = 'nathankidd@hey.com'
+  s.homepage        = 'http://github.com/general-intelligence-systems/scampi'
+end