riot 0.9.7 → 0.9.8

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+pkg

data/README.markdown

@@ -12,27 +12,40 @@ Then, simply install the Riot gem like so:
 
     sudo gem install riot
 
-### Note on speed
+#### Note on speed
 
 I have done a really simple benchmarking (10,000 runs), but right now, Riot is running about **2 times** faster than Test::unit and thusly Shoulda:
 
-    $ ruby test/benchmark/simple_context_and_assertions.rb
-
     Rehearsal ----------------------------------------------
-    Riot         0.670000   0.010000   0.680000 (  0.688571)
-    Test::Unit   1.380000   0.010000   1.390000 (  1.395437)
-    Shoulda      1.380000   0.000000   1.380000 (  1.391839)
-    ------------------------------------- total: 3.450000sec
+    Riot         0.620000   0.010000   0.630000 (  0.647318)
+    Test::Unit   1.500000   0.010000   1.510000 (  1.508144)
+    Shoulda      1.490000   0.000000   1.490000 (  1.501468)
+    ------------------------------------- total: 3.630000sec
 
                      user     system      total        real
-    Riot         0.650000   0.010000   0.660000 (  0.657817)
-    Test::Unit   1.350000   0.000000   1.350000 (  1.362907)
-    Shoulda      1.380000   0.010000   1.390000 (  1.388928)
-
-    Loaded suite test/benchmark/simple_context_and_assertions
+    Riot         0.630000   0.010000   0.640000 (  0.640481)
+    Test::Unit   1.460000   0.000000   1.460000 (  1.476454)
+    Shoulda      1.480000   0.010000   1.490000 (  1.490633)
 
 "Is it valid?", you ask. *I* think it is. I ain't no cheater, but I might be delusional.
 
+To compare against MiniTest, I had to run the benchmark separately.
+
+    Rehearsal --------------------------------------------
+    Riot       0.630000   0.010000   0.640000 (  0.641285)
+    MiniTest   0.770000   0.070000   0.840000 (  0.846447)
+    ----------------------------------- total: 1.480000sec
+
+                   user     system      total        real
+    Riot       0.630000   0.000000   0.630000 (  0.632337)
+    MiniTest   0.730000   0.070000   0.800000 (  0.798107)
+
+Riot is currently only slightly faster, but I haven't done any optimization yet. Riot is also half the code of MiniTest (`313 loc < 674 loc` :)
+
+All tests ran with `ruby 1.8.7 (2009-06-12 patchlevel 174) [i686-darwin9]`.
+
+## Examples
+
 #### Example: Basic booleans
 
 **NOTE:** For no specific reason, I'm going to use an ActiveRecord model in the following examples.
@@ -256,13 +269,14 @@ Create or modify your existing Rakefile to define a test task like so:
     desc 'Default task: run all tests'
     task :default => [:test]
     
-    desc "Run all tests"
-    task :test do
-      $:.concat ['./lib', './test']
-      Dir.glob("./test/**/*_test.rb").each { |test| require test }
+    require 'rake/testtask'
+    Rake::TestTask.new(:test) do |test|
+      test.libs << 'lib' << 'test'
+      test.pattern = 'test/**/*_test.rb'
+      test.verbose = false
     end
 
-Then, from the command line, you only need to run `rake` or `rake test`. Please make sure to remove all references to any other testing frameworks before running tests. For instance, do not require `test/unit`, `shoulda`, `minitest`, or anything else like it.
+Basically, it's like setting up any other test runner. Then, from the command line, you only need to run `rake` or `rake test`. Please make sure to remove all references to any other testing frameworks before running tests. For instance, do not require `test/unit`, `shoulda`, `minitest`, or anything else like it.
 
 ### With Sinatra
 

data/Rakefile

@@ -3,10 +3,11 @@ require 'rake'
 
 task :default => [:test]
 
-desc "Run tests"
-task :test do
-  $:.concat ['./test', './lib']
-  Dir.glob("./test/**/*_test.rb").each { |test| require test }
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
 end
 
 desc "Run Flog against library (except tests)"
@@ -23,3 +24,31 @@ desc "Run Roodi against library (except tests)"
 task :roodi do
   puts %x[find ./lib -name *.rb | xargs roodi]
 end
+
+desc "Stats on lines of code and test"
+task :stats do
+  loc = %x[find ./lib -name *.rb | xargs cat | wc -l].strip.to_i
+  lotc = %x[find ./test -name *.rb | xargs cat | wc -l].strip.to_i
+  total, ratio = (loc + lotc), (lotc / loc.to_f)
+
+  fmt = "  Code: %d\n  Test: %d\n       -----\n Total: %d  Ratio (test/code): %f"
+  puts fmt % [loc, lotc, loc + lotc, ratio]
+end
+
+#
+# Some monks like diamonds. I like gems.
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "riot"
+    gem.summary = "An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test."
+    gem.description = "An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test."
+    gem.email = "gus@gusg.us"
+    gem.homepage = "http://github.com/thumblemonks/riot"
+    gem.authors = ["Justin 'Gus' Knowlden"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.9.8

data/lib/riot.rb

@@ -1,53 +1,28 @@
+require 'riot/errors'
 require 'riot/report'
+require 'riot/situation'
 require 'riot/context'
 require 'riot/assertion'
-require 'riot/macros'
+require 'riot/assertion_macros'
 
 module Riot
 
-  def self.context(description, reporter = nil, parent = nil, &block)
-    reporter ||= self.reporter
-    context = Context.new(description, reporter, parent)
-    if block_given?
-      reporter.time { context.instance_eval(&block) }
-      context.report # Results get buffered this way, not necessarily the best
-    end
-    context
-  end
-
-  #
-  # Reporter
+  # Configuration
 
   def self.reporter; @reporter ||= (Riot.silently? ? NilReport.new : TextReport.new); end
   def self.reporter=(report); @reporter = report; end
   def self.silently!; @silently = true; end
   def self.silently?; @silently || false; end
 
-  def self.report
-    reporter.results
-    at_exit { exit false unless reporter.passed? }
-  end
-
-  at_exit { Riot.report unless Riot.silently? }
-
-  #
-  # Exceptions
-
-  class Failure < Exception
-    def print_stacktrace?; false; end
-  end
-
-  class Error < Failure
-    def initialize(message, error)
-      super(message)
-      set_backtrace(error.backtrace)
-    end
-    def print_stacktrace?; true; end
-  end
+  at_exit do
+    Riot.reporter.results
+    exit false unless reporter.passed?
+  end unless Riot.silently?
 end # Riot
 
 module Kernel
-  def context(*args, &block)
-    Riot.context(*args, &block)
+  def context(description, reporter = nil, parent = nil, &block)
+    reporter ||= Riot.reporter
+    reporter.time { Riot::Context.new(description, reporter, parent, &block) }
   end
 end # Kernel

data/lib/riot/assertion.rb

@@ -1,15 +1,14 @@
 module Riot
-
   class Assertion
     attr_reader :raised, :to_s, :description, :situation
-    def initialize(description, situation, &block)
+    def initialize(description, situation, &assertion_block)
       @description = @to_s = description
       @situation = situation
-      actualize(situation, &block)
+      run(situation, &assertion_block)
     end
 
     def actual
-      @default_failure = @failure = nil if @default_failure
+      unfail_if_default_failure_recorded
       @actual
     end
 
@@ -17,22 +16,22 @@ module Riot
       @failure = Failure.new("#{description}: #{message}") unless errored?
     end
 
+    def passed?; !(failed? || errored?); end
     def failed?; !@failure.nil?; end
     def errored?; !@raised.nil?; end
-    def passed?; !(failed? || errored?); end
-    def result; @failure || error; end
+    def result; @failure || @raised; end
   private
-    def actualize(situation, &block)
-      @actual = situation.instance_eval(&block)
+    def run(situation, &assertion_block)
+      @actual = situation.instance_eval(&assertion_block)
       @default_failure = fail("expected true, not #{@actual.inspect}") unless @actual == true
     rescue Failure => e
       @failure = e
     rescue Exception => e
-      @raised = e
+      @raised = Error.new("#{description}: errored with #{e}", e)
     end
 
-    def error
-      Error.new("#{description}: errored with #{@raised}", @raised) if errored?
+    def unfail_if_default_failure_recorded
+      @default_failure = @failure = nil if @default_failure
     end
   end # Assertion
 end # Riot

data/lib/riot/{macros.rb → assertion_macros.rb}

@@ -34,7 +34,7 @@ module Riot
     #   asserts("test") { raise My::Exception, "Foo Bar" }.raises(My::Exception, /Bar/)
     #   asserts("test") { raise My::Exception, ["a", "b"] }.raises(My::Exception, "ab")
     def raises(expected, expected_message=nil)
-      actual_error = raised
+      actual_error = raised.original_exception
       @raised = nil
       return fail("should have raised #{expected}, but raised nothing") unless actual_error
       return fail("should have raised #{expected}, not #{error.class}") unless expected == actual_error.class

data/lib/riot/context.rb

@@ -1,54 +1,44 @@
 module Riot
-  class Situation
-    def fail(message)
-      raise Failure.new(message)
-    end
-  end
-
   class Context
     # The protein
     attr_reader :description, :assertions, :situation
-    def initialize(description, reporter, parent=nil)
-      @description, @reporter = description, reporter
+    def initialize(description, reporter, parent=nil, &context_block)
+      @description, @reporter, @parent = description, reporter, parent
       @assertions = []
-      @parent = parent
       @situation = Situation.new
       bootstrap(@situation)
+      instance_eval(&context_block) if block_given? # running the context
+      report
     end
 
+    # Walk it out. Call setup from parent first
     def bootstrap(a_situation)
-      @parent.bootstrap(a_situation) if @parent # Walk it out
-      induce_local_setup(a_situation)
+      run_setup(a_situation, &@parent.bootstrap(a_situation)) if @parent
+      @setup
     end
 
-    # something smelly between setup() and bootstrap()
-    def setup(&block)
-      @setup = block
-      make_situation_topical(induce_local_setup(situation))
-    end
-
-    # DSLee stuff
-    def context(description, &block) Riot.context(description, @reporter, self, &block); end
-    def asserts(description, &block) new_assertion("asserts #{description}", &block); end
-    def should(description, &block) new_assertion("should #{description}", &block); end
-
     def report
       assertions.each { |assertion| @reporter.process_assertion(assertion) }
     end
 
     def to_s; @to_s ||= [@parent.to_s, @description].join(' ').strip; end
-  private
-    def new_assertion(description, &block)
-      (assertions << Assertion.new("#{to_s} #{description}", @situation, &block)).last
+
+    # DSLee stuff
+
+    def setup(&block)
+      run_setup(situation, &(@setup = block))
     end
 
-    def induce_local_setup(a_situation)
-      a_situation.instance_eval(&@setup) if @setup
+    def context(description, &block) Context.new(description, @reporter, self, &block); end
+    def asserts(what, &block) add_assertion("asserts #{what}", &block); end
+    def should(what, &block) add_assertion("should #{what}", &block); end
+  private
+    def add_assertion(what, &block)
+      (assertions << Assertion.new("#{to_s} #{what}", @situation, &block)).last
     end
 
-    def make_situation_topical(topic)
-      situation.instance_variable_set(:@topic, topic)
-      situation.instance_eval { def topic; @topic; end }
+    def run_setup(a_situation, &setup_block)
+      a_situation.topic = a_situation.instance_eval(&setup_block) if setup_block
     end
   end # Context
 end # Riot

data/lib/riot/errors.rb

@@ -0,0 +1,15 @@
+module Riot
+  class Failure < Exception
+    def print_stacktrace?; false; end
+  end
+
+  class Error < Failure
+    attr_reader :original_exception
+    def initialize(message, raised)
+      super(message)
+      set_backtrace(raised.backtrace)
+      @original_exception = raised
+    end
+    def print_stacktrace?; true; end
+  end
+end # Riot

data/lib/riot/report.rb

@@ -13,8 +13,9 @@ module Riot
 
     def time(&block)
       @start = Time.now
-      yield
+      result = yield
       @time_taken += (Time.now - @start).to_f
+      result
     end
 
     def process_assertion(assertion)
@@ -63,19 +64,19 @@ module Riot
 
     def results
       @writer.puts "\n\n"
-      print_result_stack
+      print_bad_results
       format = "%d assertions, %d failures, %d errors in %s seconds"
       @writer.puts format % [assertions, failures, errors, ("%0.6f" % time_taken)]
     end
   private
-    def print_result_stack
+    def print_bad_results
       bad_results.each_with_index do |result, idx|
-        @writer.puts render_result(idx + 1, result)
+        @writer.puts format_result(idx + 1, result)
         @writer.puts "  " + result.backtrace.join("\n  ") if result.print_stacktrace?
-        @writer.puts "\n\n"
+        @writer.puts "\n"
       end
     end
 
-    def render_result(idx, result) "#%d - %s" % [idx, result.to_s]; end
+    def format_result(idx, result) "#%d - %s" % [idx, result.to_s]; end
   end # TextReport
 end # Riot

data/lib/riot/situation.rb

@@ -0,0 +1,9 @@
+module Riot
+  class Situation
+    attr_accessor :topic
+
+    def fail(message)
+      raise Failure.new(message)
+    end
+  end # Situation
+end # Riot

data/riot.gemspec

@@ -1,42 +1,76 @@
-Gem::Specification.new do |s|
-  s.name     = "riot"
-  s.version  = "0.9.7"
-  s.date     = "2009-10-07"
-  s.summary  = "An extremely fast, expressive, and context-driven unit-testing framework"
-  s.email    = %w[gus@gusg.us]
-  s.homepage = "http://github.com/thumblemonks/protest"
-  s.description = "An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test."
-  s.authors  = %w[Justin\ Knowlden]
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
 
-  s.has_rdoc = false
-  s.rdoc_options = ["--main", "README.markdown"]
-  s.extra_rdoc_files = ["README.markdown"]
+Gem::Specification.new do |s|
+  s.name = %q{riot}
+  s.version = "0.9.8"
 
-  # run git ls-files to get an updated list
-  s.files = %w[
-    MIT-LICENSE
-    README.markdown
-    lib/riot.rb
-    lib/riot/assertion.rb
-    lib/riot/context.rb
-    lib/riot/macros.rb
-    lib/riot/report.rb
-    riot.gemspec
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Justin 'Gus' Knowlden"]
+  s.date = %q{2009-10-10}
+  s.description = %q{An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test.}
+  s.email = %q{gus@gusg.us}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/riot.rb",
+     "lib/riot/assertion.rb",
+     "lib/riot/assertion_macros.rb",
+     "lib/riot/context.rb",
+     "lib/riot/errors.rb",
+     "lib/riot/report.rb",
+     "lib/riot/situation.rb",
+     "riot.gemspec",
+     "test/assertion_macros/assertion_macro_assigns_test.rb",
+     "test/assertion_macros/assertion_macro_equals_test.rb",
+     "test/assertion_macros/assertion_macro_exists_test.rb",
+     "test/assertion_macros/assertion_macro_kind_of_test.rb",
+     "test/assertion_macros/assertion_macro_matching_test.rb",
+     "test/assertion_macros/assertion_macro_nil_test.rb",
+     "test/assertion_macros/assertion_macro_raises_test.rb",
+     "test/assertion_macros/assertion_macro_respond_to_test.rb",
+     "test/assertion_test.rb",
+     "test/benchmark/riot_vs_minitest.rb",
+     "test/benchmark/simple_context_and_assertions.rb",
+     "test/context_test.rb",
+     "test/teststrap.rb"
   ]
-  
-  s.test_files = %w[
-    Rakefile
-    test/assertion_macros/assertion_macro_assigns_test.rb
-    test/assertion_macros/assertion_macro_equals_test.rb
-    test/assertion_macros/assertion_macro_exists_test.rb
-    test/assertion_macros/assertion_macro_kind_of_test.rb
-    test/assertion_macros/assertion_macro_matching_test.rb
-    test/assertion_macros/assertion_macro_nil_test.rb
-    test/assertion_macros/assertion_macro_raises_test.rb
-    test/assertion_macros/assertion_macro_respond_to_test.rb
-    test/assertion_test.rb
-    test/benchmark/simple_context_and_assertions.rb
-    test/context_test.rb
-    test/teststrap.rb
+  s.homepage = %q{http://github.com/thumblemonks/riot}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.}
+  s.test_files = [
+    "test/assertion_macros/assertion_macro_assigns_test.rb",
+     "test/assertion_macros/assertion_macro_equals_test.rb",
+     "test/assertion_macros/assertion_macro_exists_test.rb",
+     "test/assertion_macros/assertion_macro_kind_of_test.rb",
+     "test/assertion_macros/assertion_macro_matching_test.rb",
+     "test/assertion_macros/assertion_macro_nil_test.rb",
+     "test/assertion_macros/assertion_macro_raises_test.rb",
+     "test/assertion_macros/assertion_macro_respond_to_test.rb",
+     "test/assertion_test.rb",
+     "test/benchmark/riot_vs_minitest.rb",
+     "test/benchmark/simple_context_and_assertions.rb",
+     "test/context_test.rb",
+     "test/teststrap.rb"
   ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
 end

data/test/benchmark/riot_vs_minitest.rb

@@ -0,0 +1,56 @@
+$:.concat ['./lib']
+require 'benchmark'
+
+#
+# Model
+
+class Room
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+end
+
+#
+# Riot
+
+require 'riot'
+Riot.silently!
+
+#
+# MiniTest::Unit
+
+require 'rubygems'
+require 'minitest/unit'
+
+class RoomTest < MiniTest::Unit::TestCase
+  def setup
+    @room = Room.new("bed")
+  end
+
+  def test_room_should_be_named_bed
+    assert_equal "bed", @room.name
+  end
+end
+
+#
+# Benchmarking
+
+n = 100 * 100
+
+Benchmark.bmbm do |x|
+  x.report("Riot") do
+    n.times do
+      context "a room" do
+        setup { Room.new("bed") }
+
+        asserts("name") { topic.name }.equals("bed")
+      end # a room
+    end
+  end
+
+  x.report("MiniTest") do
+    n.times { RoomTest.new("Blah").run(MiniTest::Unit.new) }
+  end
+end
+

metadata

@@ -1,21 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: riot
 version: !ruby/object:Gem::Version 
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors: 
-- Justin Knowlden
+- Justin 'Gus' Knowlden
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-10-07 00:00:00 -05:00
+date: 2009-10-10 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
 description: An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks. Protest the slow test.
-email: 
-- gus@gusg.us
+email: gus@gusg.us
 executables: []
 
 extensions: []
@@ -23,22 +22,39 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
+- .gitignore
 - MIT-LICENSE
 - README.markdown
+- Rakefile
+- VERSION
 - lib/riot.rb
 - lib/riot/assertion.rb
+- lib/riot/assertion_macros.rb
 - lib/riot/context.rb
-- lib/riot/macros.rb
+- lib/riot/errors.rb
 - lib/riot/report.rb
+- lib/riot/situation.rb
 - riot.gemspec
+- test/assertion_macros/assertion_macro_assigns_test.rb
+- test/assertion_macros/assertion_macro_equals_test.rb
+- test/assertion_macros/assertion_macro_exists_test.rb
+- test/assertion_macros/assertion_macro_kind_of_test.rb
+- test/assertion_macros/assertion_macro_matching_test.rb
+- test/assertion_macros/assertion_macro_nil_test.rb
+- test/assertion_macros/assertion_macro_raises_test.rb
+- test/assertion_macros/assertion_macro_respond_to_test.rb
+- test/assertion_test.rb
+- test/benchmark/riot_vs_minitest.rb
+- test/benchmark/simple_context_and_assertions.rb
+- test/context_test.rb
+- test/teststrap.rb
 has_rdoc: true
-homepage: http://github.com/thumblemonks/protest
+homepage: http://github.com/thumblemonks/riot
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --main
-- README.markdown
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -59,9 +75,8 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: An extremely fast, expressive, and context-driven unit-testing framework
+summary: An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
 test_files: 
-- Rakefile
 - test/assertion_macros/assertion_macro_assigns_test.rb
 - test/assertion_macros/assertion_macro_equals_test.rb
 - test/assertion_macros/assertion_macro_exists_test.rb
@@ -71,6 +86,7 @@ test_files:
 - test/assertion_macros/assertion_macro_raises_test.rb
 - test/assertion_macros/assertion_macro_respond_to_test.rb
 - test/assertion_test.rb
+- test/benchmark/riot_vs_minitest.rb
 - test/benchmark/simple_context_and_assertions.rb
 - test/context_test.rb
 - test/teststrap.rb