riot 0.10.11 → 0.10.12.pre

data/lib/riot/message.rb

@@ -0,0 +1,23 @@
+class BlankSlate
+  instance_methods.each { |meth| undef_method(meth) unless meth =~ /^__/ }
+end
+
+module Riot
+  class Message < BlankSlate
+    def initialize(*phrases)
+      @chunks = []; _inspect(phrases)
+    end
+
+    def to_s; @chunks.join.strip; end
+
+    def method_missing(meth, *phrases, &blk) push(meth.to_s.gsub('_', ' ')); _inspect(phrases); end
+
+    def comma(str, *phrases) _concat([", ", str]); _inspect(phrases); end
+    def but(*phrases); comma("but", *phrases); end
+    def not(*phrases); comma("not", *phrases); end
+    def push(str) _concat([" ", str]); end
+  private
+    def _concat(chunks) @chunks.concat(chunks); self; end
+    def _inspect(phrases) phrases.each { |phrase| push(phrase.inspect) }; self; end
+  end # Message
+end # Riot

data/lib/riot/rr.rb

@@ -0,0 +1,35 @@
+require 'rr'
+
+module Riot
+  module RR
+
+    class Situation < Riot::Situation
+      include ::RR::Adapters::RRMethods
+    end # Situation
+
+    class Assertion < Riot::Assertion
+      def run(situation)
+        result = super
+        situation.verify
+        result
+      rescue ::RR::Errors::RRError => e
+        [:fail, e.message.gsub(/\n/, " ")]
+      ensure
+        situation.reset
+      end
+    end # Assertion
+
+    module ContextHelpers
+    private
+      def assertion_class; Riot::RR::Assertion; end
+      def situation_class; Riot::RR::Situation; end
+    end # ContextHelpers
+
+    def self.enable(context_class)
+      context_class.instance_eval { include Riot::RR::ContextHelpers }
+    end
+
+  end # RR
+end # Riot
+
+Riot::RR.enable(Riot::Context)

data/lib/riot/runnable.rb

@@ -18,4 +18,16 @@ module Riot
       [:setup]
     end
   end # Setup
+
+  class Helper < RunnableBlock
+    def initialize(name, &definition)
+      super("helper #{name}", &definition)
+      @name = name
+    end
+
+    def run(situation)
+      situation.helper(@name, &definition)
+      [:helper]
+    end
+  end
 end # Riot

data/lib/riot/situation.rb

@@ -5,6 +5,10 @@ module Riot
       @topic = self.instance_eval(&block)
     end
 
+    def helper(name, &block)
+      (class << self; self; end).send(:define_method, name, &block)
+    end
+
     def evaluate(&block)
       self.instance_eval(&block)
     end

data/riot.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{riot}
-  s.version = "0.10.11"
+  s.version = "0.10.12.pre"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin 'Gus' Knowlden"]
-  s.date = %q{2009-12-29}
+  s.date = %q{2010-02-09}
   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 = [
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
      "lib/riot/assertion_macros/assigns.rb",
      "lib/riot/assertion_macros/empty.rb",
      "lib/riot/assertion_macros/equals.rb",
+     "lib/riot/assertion_macros/equivalent_to.rb",
      "lib/riot/assertion_macros/exists.rb",
      "lib/riot/assertion_macros/includes.rb",
      "lib/riot/assertion_macros/kind_of.rb",
@@ -41,14 +42,18 @@ Gem::Specification.new do |s|
      "lib/riot/assertion_macros/same_elements.rb",
      "lib/riot/assertion_macros/size.rb",
      "lib/riot/context.rb",
+     "lib/riot/message.rb",
      "lib/riot/reporter.rb",
+     "lib/riot/rr.rb",
      "lib/riot/runnable.rb",
      "lib/riot/situation.rb",
      "riot.gemspec",
+     "test/assertion_macro_test.rb",
      "test/assertion_macros/any_test.rb",
      "test/assertion_macros/assigns_test.rb",
      "test/assertion_macros/empty_test.rb",
      "test/assertion_macros/equals_test.rb",
+     "test/assertion_macros/equivalent_to_test.rb",
      "test/assertion_macros/exists_test.rb",
      "test/assertion_macros/includes_test.rb",
      "test/assertion_macros/kind_of_test.rb",
@@ -61,10 +66,13 @@ Gem::Specification.new do |s|
      "test/assertion_macros/size_test.rb",
      "test/assertion_test.rb",
      "test/benchmark/colorize.rb",
+     "test/benchmark/message_concatenation.rb",
      "test/benchmark/riot_vs_minitest.rb",
      "test/benchmark/same_elements_vs_set.rb",
      "test/benchmark/simple_context_and_assertions.rb",
      "test/context_test.rb",
+     "test/extensions/rrriot_test.rb",
+     "test/message_test.rb",
      "test/report_test.rb",
      "test/setup_test.rb",
      "test/situation_test.rb",
@@ -77,10 +85,12 @@ Gem::Specification.new do |s|
   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/any_test.rb",
+    "test/assertion_macro_test.rb",
+     "test/assertion_macros/any_test.rb",
      "test/assertion_macros/assigns_test.rb",
      "test/assertion_macros/empty_test.rb",
      "test/assertion_macros/equals_test.rb",
+     "test/assertion_macros/equivalent_to_test.rb",
      "test/assertion_macros/exists_test.rb",
      "test/assertion_macros/includes_test.rb",
      "test/assertion_macros/kind_of_test.rb",
@@ -93,10 +103,13 @@ Gem::Specification.new do |s|
      "test/assertion_macros/size_test.rb",
      "test/assertion_test.rb",
      "test/benchmark/colorize.rb",
+     "test/benchmark/message_concatenation.rb",
      "test/benchmark/riot_vs_minitest.rb",
      "test/benchmark/same_elements_vs_set.rb",
      "test/benchmark/simple_context_and_assertions.rb",
      "test/context_test.rb",
+     "test/extensions/rrriot_test.rb",
+     "test/message_test.rb",
      "test/report_test.rb",
      "test/setup_test.rb",
      "test/situation_test.rb",
@@ -109,11 +122,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rr>, [">= 0"])
       s.add_runtime_dependency(%q<term-ansicolor>, [">= 0"])
     else
+      s.add_dependency(%q<rr>, [">= 0"])
       s.add_dependency(%q<term-ansicolor>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rr>, [">= 0"])
     s.add_dependency(%q<term-ansicolor>, [">= 0"])
   end
 end

data/test/assertion_macro_test.rb

@@ -0,0 +1,30 @@
+require 'teststrap'
+
+context "An AssertionMacro instance" do
+  setup { Riot::AssertionMacro.new }
+
+  asserts_topic.responds_to(:new_message)
+  asserts_topic.responds_to(:expected_message)
+  asserts_topic.responds_to(:should_have_message)
+
+  context "receiving #new_message" do
+    setup { topic.new_message("hope") }
+
+    asserts_topic.kind_of(Riot::Message)
+    asserts(:to_s).equals(%q["hope"])
+  end
+
+  context "receiving #should_have_message" do
+    setup { topic.should_have_message("hope") }
+
+    asserts_topic.kind_of(Riot::Message)
+    asserts(:to_s).equals(%q[should have "hope"])
+  end
+
+  context "receiving #expected_message" do
+    setup { topic.expected_message("hope") }
+
+    asserts_topic.kind_of(Riot::Message)
+    asserts(:to_s).equals(%q[expected "hope"])
+  end
+end # An AssertionMacro instance

data/test/assertion_macros/assigns_test.rb

@@ -10,15 +10,15 @@ context "An assigns assertion macro" do
   assertion_test_passes("when foo is defined") { topic.assigns(:foo) }
   assertion_test_passes("when foo is defined with expected value") { topic.assigns(:foo, 1) }
 
-  assertion_test_fails("when foo does not match expectation", "expected @foo to be equal to 2, not 1") do
+  assertion_test_fails("when foo does not match expectation", "expected :foo to be equal to 2, not 1") do
     topic.assigns(:foo, 2)
   end
 
-  assertion_test_fails("when bar is not define", "expected @bar to be assigned a value") do
+  assertion_test_fails("when bar is not define", "expected :bar to be assigned a value") do
     topic.assigns(:bar)
   end
 
-  assertion_test_fails("when var assigned nil value", "expected @nil_val to be assigned a value") do
+  assertion_test_fails("when var assigned nil value", "expected :nil_val to be assigned a value") do
     topic.assigns(:nil_val)
   end
 end # An assigns assertion macro

data/test/assertion_macros/equals_test.rb

@@ -24,15 +24,8 @@ context "An equals assertion macro" do
       Riot::Assertion.new("blue") { 31415 }
     end
 
-    asserts(":pass when in expected range") do
-      topic.equals(30000..32000).run(Riot::Situation.new) == [:pass, "is equal to 30000..32000"]
-    end
-
-    context "when not in expected range" do
-      setup { topic.equals(32000..33000).run(Riot::Situation.new) }
-
-      asserts(":fail") { topic.first == :fail }
-      asserts("message") { topic.last == %Q{expected 32000..33000, not 31415} }
+    asserts("failure") do
+      topic.equals(30000..32000).run(Riot::Situation.new) == [:fail, "expected 30000..32000, not 31415"]
     end
   end # with numeric topic
 

data/test/assertion_macros/equivalent_to_test.rb

@@ -0,0 +1,36 @@
+require 'teststrap'
+
+# Using == to verify the test because this is the test for :equals itself. Look at assertion_test_passes
+# and assertion_test_fails for testing other macros.
+
+context "An equivalent_to assertion macro" do
+  setup do
+    Riot::Assertion.new("red") { "what" }
+  end
+
+  asserts("String is equivalent to 'what'") do
+    topic.equivalent_to(String).run(Riot::Situation.new) == [:pass, %Q{is equivalent to String}]
+  end
+
+  asserts("an array is not equivalent to 'what'") do
+    topic.equivalent_to([]).run(Riot::Situation.new) == [:fail, %Q{expected "what" to be equivalent to []}]
+  end
+
+  context "with numeric topic" do
+    setup do
+      Riot::Assertion.new("blue") { 31413 }
+    end
+
+    asserts(":pass when in expected range") do
+      topic.equivalent_to(30000..32000).run(Riot::Situation.new) == [:pass, "is equivalent to 30000..32000"]
+    end
+
+    context "when not in expected range" do
+      setup { topic.equivalent_to(32000..33000).run(Riot::Situation.new) }
+
+      asserts(":fail") { topic.first == :fail }
+      asserts("message") { topic.last == %Q{expected 31413 to be equivalent to 32000..33000} }
+    end
+  end # with numeric topic
+
+end # An equivalent_to assertion macro

data/test/assertion_macros/respond_to_test.rb

@@ -4,6 +4,7 @@ context "A respond_to assertion macro" do
   setup { Riot::Assertion.new("foo") { "bar" } }
 
   assertion_test_passes("when method is defined", "responds to :each_byte") { topic.respond_to(:each_byte) }
+  assertion_test_passes("using responds_to alias", "responds to :length") { topic.responds_to(:length) }
 
   assertion_test_fails("when method not defined", "expected method :goofballs is not defined") do
     topic.respond_to(:goofballs)

data/test/assertion_macros/size_test.rb

@@ -14,10 +14,10 @@ context "A size assertion macro" do
     assert_size("washington", 9..12)
   end
 
-  assertion_test_fails("when string's size is not as expected", "size of \"washington\" expected to be 11 but is 10") do
+  assertion_test_fails("when string's size is not as expected", "expected size of \"washington\" to be 11, not 10") do
     assert_size("washington", 11)
   end
-  assertion_test_fails("when string's size is out of range", "size of \"washington\" expected to be 11..13 but is 10") do
+  assertion_test_fails("when string's size is out of range", "expected size of \"washington\" to be 11..13, not 10") do
     assert_size("washington", 11..13)
   end
 
@@ -25,10 +25,10 @@ context "A size assertion macro" do
   assertion_test_passes("when an array's size is in given range", "is of size 3..4") do
     assert_size([1, 2, 3], 3..4)
   end
-  assertion_test_fails("when an array's size is not as expected", "size of [1, 2, 3] expected to be 2 but is 3") do
+  assertion_test_fails("when an array's size is not as expected", "expected size of [1, 2, 3] to be 2, not 3") do
     assert_size([1, 2, 3], 2)
   end
-  assertion_test_fails("when an array's size is out of range", "size of [1, 2, 3] expected to be 4..6 but is 3") do
+  assertion_test_fails("when an array's size is out of range", "expected size of [1, 2, 3] to be 4..6, not 3") do
     assert_size([1, 2, 3], 4..6)
   end
 
@@ -38,10 +38,10 @@ context "A size assertion macro" do
   assertion_test_passes("when a hash size is in range", "is of size 1...3") do
     assert_size({:name => 'washington'}, 1...3)
   end
-  assertion_test_fails("when a hash size is not as expected", "size of {} expected to be 2 but is 0") do
+  assertion_test_fails("when a hash size is not as expected", "expected size of {} to be 2, not 0") do
     assert_size({}, 2)
   end
-  assertion_test_fails("when a hash size is out of range", "size of {} expected to be 2...4 but is 0") do
+  assertion_test_fails("when a hash size is out of range", "expected size of {} to be 2...4, not 0") do
     assert_size({}, 2...4)
   end
 end

data/test/assertion_test.rb

@@ -6,7 +6,7 @@ context "An assertion" do
     asserts("to_s") { topic.to_s == "foo" }
 
     asserts(":pass is returned when evaluated") do
-      topic.run(Riot::Situation.new) == [:pass, nil]
+      topic.run(Riot::Situation.new) == [:pass, ""]
     end
   end # that is passing
 

data/test/benchmark/message_concatenation.rb

@@ -0,0 +1,82 @@
+require 'benchmark'
+
+class BlankSlate
+  instance_methods.each { |meth| undef_method(meth) unless meth =~ /^__/ }
+end
+
+class NormalMessage < BlankSlate
+  def initialize(*phrases)
+    @message = ""; _phrase(*phrases)
+  end
+  
+  def to_s; @message; end
+
+  def method_missing(meth, *phrases, &blk) push(meth.to_s.gsub('_', ' ')); _phrase(*phrases); end
+
+  def comma(str, *phrases) raise Exception, "Whoops - comma"; end
+  def but(*phrases); comma("but", *phrases); end
+  def not(*phrases); comma("not", *phrases); end
+  def push(str) raise Exception, "Whoops - push"; end
+private
+  def _concat(str) (@message << str).strip!; self; end
+  def _phrase(*phrases) phrases.each { |phrase| push(phrase.inspect) }; self; end
+end # Message
+
+# +
+
+class PlusMessage < NormalMessage
+  def comma(str, *phrases) _concat(", " + str); _phrase(*phrases); end
+  def push(str) _concat(" " + str); end
+end # Message
+
+# <<
+
+class AppendMessage < NormalMessage
+  def comma(str, *phrases) _concat(", " << str); _phrase(*phrases); end
+  def push(str) _concat(" " << str); end
+end # Message
+
+# Experimental
+
+class ExperimentalMessage < BlankSlate
+  def initialize(*phrases)
+    @chunks = []; _inspect(phrases)
+  end
+  
+  def to_s; @chunks.join; end
+
+  def method_missing(meth, *phrases, &blk) push(meth.to_s.gsub('_', ' ')); _inspect(phrases); end
+
+  def comma(str, *phrases) _concat([", ", str]); _inspect(phrases); end
+  def but(*phrases); comma("but", *phrases); end
+  def not(*phrases); comma("not", *phrases); end
+  def push(str) _concat([" ", str]); end
+private
+  def _concat(chunks) @chunks.concat(chunks); self; end
+  def _inspect(phrases) phrases.each { |phrase| push(phrase.inspect) }; self; end
+end # Message
+
+#
+# Benchmarking
+
+Benchmark.bmbm do |x|
+  def message_test(klass)
+    STDOUT.puts(klass.new.comma("yes").push("no").foo.bar("baz").to_s)
+    10_000.times do
+      klass.new.comma("yes").push("no").foo.bar("baz").to_s
+    end
+  end
+
+  x.report("+ based message") do
+    message_test(PlusMessage)
+  end
+
+  x.report("<< based message") do
+    message_test(AppendMessage)
+  end
+
+  x.report("experimental message") do
+    message_test(ExperimentalMessage)
+  end
+end
+

data/test/context_test.rb

@@ -88,13 +88,12 @@ context "The asserts_topic shortcut" do
     topic.equals("bar").run(situation)
   end.equals([:pass, %Q{is equal to "bar"}])
 
-  asserts(:to_s).equals("asserts topic")
+  asserts(:to_s).equals("asserts that it")
 
   context "with an explicit description" do
     setup { Riot::Context.new("foo") {}.asserts_topic("get some") }
     asserts(:to_s).equals("asserts get some")
   end
-
 end # The asserts_topic shortcut
 
 context "Using a hookup" do
@@ -108,3 +107,19 @@ context "Using a hookup" do
   
   asserts_topic.equals("I'm a string")
 end # Using a hookup
+
+context "Making a new context" do
+  asserts("RootContext is used if nil parent is provided") do
+    Riot::Context.new("hello", nil) {}.parent
+  end.kind_of(Riot::RootContext)
+end # Making a context
+
+context "A context with a helper" do
+  setup { "foo" }
+
+  helper(:upcase) { topic.upcase }
+  helper(:append) {|str| topic + str }
+
+  asserts("executing the helper") { upcase }.equals("FOO")
+  asserts("calling a helper with an argument") { append("bar") }.equals("foobar")
+end