riot 0.10.9 → 0.10.10

data/CHANGELOG

@@ -0,0 +1,46 @@
+*0.10.10*
+
+* Passing assertion macros can now return a custom message [dasch, jaknowlden]
+
+    def evaluate(actual, *expectings)
+      1 == 1 ? pass("1 does equal 1") : fail("1 does not equal 1 in this universe")
+    end
+
+* Removing Context#extend_assertions and related code [jaknowlden]
+
+* Allow the use of symbolic descriptions as shorthands for sending the message to the topic [dasch]
+
+    setup { "foo" }
+    asserts(:upcase).equals("FOO")
+
+* Added AssertionMacro and #register for macros [jaknowlden, splattael]
+
+    module My
+      class CustomThingAssertion < Riot::AssertionMacro
+        register :custom_thing
+        expects_exception!
+
+        def evaluate(actual, *expectings)
+          # ...
+        end
+      end
+      
+      Riot::Assertion.register_macro :custom_thing, CustomThingAssertion
+    end
+
+* Replace IOReporter#say with #puts. Also add #print. [splattael]
+
+    class SomeNewReporter < IOReporter
+      def pass
+        puts "I PASSED"
+      end
+
+      def fail
+        print "F"
+      end
+      # ...
+    end
+
+*0.10.9 and before*
+
+See [commit log](http://github.com/thumblemonks/riot/commits/master)

data/README.markdown

@@ -44,7 +44,7 @@ Then, simply install the Riot gem like so:
 <a name="speed"></a>
 #### 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:
+I have done a really simple benchmarking (10,000 runs), but right now, Riot is running about **3 times** faster than Test::Unit and thusly Shoulda:
 
     Rehearsal ----------------------------------------------
     Riot         0.360000   0.000000   0.360000 (  0.364236)
@@ -112,8 +112,9 @@ The other important thing to note in the examples above is the use of the `topic
 I'm going to use `asserts` for the rest of this introduction, but you should know that you can replace any instance of `asserts` with `should` and nothing would change.
 
 <a name="examples-shortcut"></a>
-#### Example: Shortcut - Asserting the topic itself
+#### Example: Shortcuts
 
+##### Asserting the topic itself
 Over the course of developing Riot it became somewhat obvious to some of us that we were creating assertions that returned the `topic` just so we could assert things about the topic itself. For instance, were doing this:
 
     context "a billionaire" do
@@ -129,16 +130,31 @@ This is awfully redundant - not to mention, contrived. So, we wrote a shortcut t
       asserts_topic.kind_of(Billionaire)
     end
 
-If you'd like to add a description to your assertion about the topic,
-but still would like to avoid the redundancy of an assertion simply
-returning the topic from it's block, you can omit the block all
-together as follows:
+If you'd like to add a description to your assertion about the topic, but still would like to avoid the redundancy of an assertion simply returning the topic from it's block, you can omit the block all together as follows:
 
     context "a trazillionaire" do
       setup { MoneyMaker.build(:trazillionaire) }
       asserts("is a trazillionaire").kind_of(Trazillionaire)
     end
 
+##### Asserting methods on topic
+
+A very common assertion pattern with Riot is calling a method on the topic and asserting it's output. For instance, the following is not an uncommon thing to see in an `ActiveRecord` test:
+
+    context "A new post" do
+      setup { Post.new(:name => "Howdy ya'll") }
+      asserts("name") { topic.name }.equals("Howdy ya'll")
+    end
+
+Since Riot is all about reducing redundancy and increasing semantics, it makes a ton of sense to be able to do this instead:
+
+    context "A new post" do
+      setup { Post.new(:name => "Howdy ya'll") }
+      asserts(:name).equals("Howdy ya'll")
+    end
+
+And now you can! Isn't that just so much easier to read?
+
 <a name="examples-equality"></a>
 #### Example: Equality
 
@@ -410,7 +426,10 @@ And then define a context (or many) for testing your Sinatra app. For instance:
       end
     end
 
-Make sure to check out the Riot + Sinatra testing macros in Chicago.
+Make sure to check out the Riot + Sinatra testing macros in Chicago. If you do happen to use Chicago, the above `test_helper.rb` setup can be compressed to the following while allowing the same test to work:
+
+    require 'riot'
+    require 'chicago/riot'
 
 <a name="rails"></a>
 ### With Rails
@@ -449,19 +468,23 @@ And then in your actual test, you might do the following:
 <a name="assertion-macros"></a>
 #### Assertion macros
 
-If you want to add special macros to an Assertion, this is as easy as adding them to a Context. Assertion macros, however, have a special mechanism for adding themselves onto an assertion. Thus, you will want to open the Riot::Assertion class and then define your assertion macro.
+If you want to add special macros to an Assertion, the process is really very easy. You simple need to define a class that extends `AssertionMacro` (or at least quacks like it), be sure to implement the `evaluate` instance method, and then register the macro.
 
-For instance, let's say you wanted to add a macro for verifying that the result of an assertion is the same kind\_of object as you would expect. You would define the macro like so:
+For instance, let's say you wanted to add a macro for verifying that the result of an assertion is the same `kind\_of` object as you would expect. You would define the macro like so:
 
-    module Riot
-      class Assertion
+    module Foo
+      class KindOfMacro < Riot::AssertionMacro
+        register :kind_of
 
-        assertion(:kind_of) do |actual, expected|
-          actual.kind_of?(expected) ? pass : fail("expected kind of #{expected}, not #{actual.inspect}")
+        def evaluate(actual, expected)
+          if actual.kind_of?(expected)
+            pass("is a kind of #{expected.inspect}")
+          else
+            fail("expected kind of #{expected}, not #{actual.inspect}")
+          end
         end
-
-      end # Assertion
-    end # Riot
+      end # KindOfMacro
+    end # Foo
 
 And in your context, you would use it like so:
 
@@ -469,4 +492,18 @@ And in your context, you would use it like so:
       asserts("a hash is defined") { {:foo => 'bar'} }.kind_of(Hash)
     end
 
+If your assertion macro expects to be called only when an exception occurs, there's support for that, too. Check this:
+
+    module Foo
+      class RaisesMacro < Riot::AssertionMacro
+        register :raises
+        expects_exception! # THE IMPORTANT LINE
+
+        def evaluate(actual, expected)
+          # ... pass/fail code
+        end
+      end # RaisesMacro
+    end # Foo
+
+
 If you think you might want to chain assertions checks together, this won't work out the box. The reason for this is that your assertion macro should call out to pass or fail, which each return a signal that will be used by the reporter. You could conceivably write an assertion as a filter macro instead, that would return `self`, but I can't decide why you would do that yet (in theory it would work, though).

data/Rakefile

@@ -11,6 +11,14 @@ Rake::TestTask.new(:test) do |test|
   test.verbose =  false
 end
 
+desc "Run all of them fancy benchmarks, Howard!"
+task :benchmarks do
+  Dir["test/benchmark/*.rb"].each do |file|
+    puts ">> Running #{file}"
+    puts %x[ruby #{file}]
+  end
+end
+
 desc "Run Flog against library (except tests)"
 task :flog do
   puts %x[find ./lib -name *.rb | xargs flog]

data/VERSION

@@ -1 +1 @@
-0.10.9
+0.10.10

data/lib/riot.rb

@@ -3,7 +3,7 @@ require 'riot/context'
 require 'riot/situation'
 require 'riot/runnable'
 require 'riot/assertion'
-require 'riot/assertion_macros'
+require 'riot/assertion_macro'
 
 module Riot
   def self.context(description, context_class = Context, &definition)

data/lib/riot/assertion.rb

@@ -1,45 +1,32 @@
 module Riot
   class Assertion < RunnableBlock
-  
-    def initialize(description, &definition)
-      super
-      @expectings, @expect_exception, @expectation_block = [], false, nil
-      @assertion_block = lambda do |actual|
-        actual ? self.class.pass : self.class.fail("Expected non-false but got #{actual.inspect} instead")
-      end
-    end
-
     class << self
-      def pass() [:pass]; end
-      def fail(message) [:fail, message]; end
-      def error(e) [:error, e]; end
-      def assertions; @assertions ||= {}; end
+      def macros; @macros ||= {}; end
 
-      # TODO: Make everyone switch to 1.8.7 or above so we can go mostly stateless again.
-      # Had to do this for 1.8.6 compatibility  {:() I'm a sad sock monkey
-      def assertion(name, expect_exception=false, &assertion_block)
-        assertions[name] = [expect_exception, assertion_block]
-        class_eval <<-EOC
-          def #{name}(*expectings, &expectation_block)
-            @expectings, @expectation_block = expectings, expectation_block
-            @expect_exception, @assertion_block = self.class.assertions[#{name.inspect}]
-            self
-          end
-        EOC
+      def register_macro(name, assertion_macro, expect_exception=false)
+        macros[name.to_s] = assertion_macro.new
       end
     end
 
-    def run(situation)
-      @expectings << situation.evaluate(&@expectation_block) if @expectation_block
-      process_macro(situation, @expect_exception) { |actual| @assertion_block.call(actual, *@expectings) }
+    def initialize(description, &definition)
+      super
+      @expectings, @expectation_block = [], false, nil
+      @macro = AssertionMacro.default
     end
 
-  private
-    def process_macro(situation, expect_exception)
+    def run(situation)
+      @expectings << situation.evaluate(&@expectation_block) if @expectation_block
       actual = situation.evaluate(&definition)
-      yield(expect_exception ? nil : actual)
+      @macro.evaluate((@macro.expects_exception? ? nil : actual), *@expectings)
     rescue Exception => e
-      expect_exception ? yield(e) : self.class.error(e)
+      @macro.expects_exception? ? @macro.evaluate(e, *@expectings) : @macro.error(e)
+    end
+  private
+    def enhance_with_macro(name, *expectings, &expectation_block)
+      @macro, @expectings, @expectation_block = self.class.macros[name.to_s], expectings, expectation_block
+      raise(NoMethodError, name) unless @macro
+      self
     end
+    alias :method_missing :enhance_with_macro
   end # Assertion
 end # Riot

data/lib/riot/assertion_macro.rb

@@ -0,0 +1,35 @@
+module Riot
+  class AssertionMacro
+    class << self
+      attr_reader :expects_exception
+
+      def default; @default_macro ||= new; end
+      def expects_exception!; @expects_exception = true; end
+      def register(name); Assertion.register_macro name, self; end
+    end
+
+    def pass(message=nil) [:pass, message]; end
+    def fail(message) [:fail, message]; end
+    def error(e) [:error, e]; end
+
+    def expects_exception?; self.class.expects_exception; end
+
+    def evaluate(actual)
+      actual ? pass : fail("Expected non-false but got #{actual.inspect} instead")
+    end
+  end
+end
+
+require 'riot/assertion_macros/any'
+require 'riot/assertion_macros/assigns'
+require 'riot/assertion_macros/empty'
+require 'riot/assertion_macros/equals'
+require 'riot/assertion_macros/exists'
+require 'riot/assertion_macros/includes'
+require 'riot/assertion_macros/kind_of'
+require 'riot/assertion_macros/matches'
+require 'riot/assertion_macros/nil'
+require 'riot/assertion_macros/raises'
+require 'riot/assertion_macros/respond_to'
+require 'riot/assertion_macros/same_elements'
+require 'riot/assertion_macros/size'

data/lib/riot/assertion_macros/any.rb

@@ -0,0 +1,12 @@
+module Riot
+  # Asserts the result has items
+  #   asserts("an array") { [1] }.any
+  #   asserts("a hash") { {:name => 'washington'} }.any
+  class AnyMacro < AssertionMacro
+    register :any
+
+    def evaluate(actual)
+      actual.any? ? pass("is not empty") : fail("expected #{actual.inspect} to have items")
+    end
+  end
+end

data/lib/riot/assertion_macros/assigns.rb

@@ -0,0 +1,27 @@
+module Riot
+  # Asserts that an instance variable is defined for the result of the assertion. Value of instance
+  # variable is expected to not be nil
+  #   setup { User.new(:email => "foo@bar.baz") }
+  #   topic.assigns(:email)
+  #
+  # If a value is provided in addition to the variable name, the actual value of the instance variable
+  # must equal the expected value
+  #   setup { User.new(:email => "foo@bar.baz") }
+  #   topic.assigns(:email, "foo@bar.baz")
+  class AssignsMacro < AssertionMacro
+    register :assigns
+
+    def evaluate(actual, *expectings)
+      variable, expected_value = expectings
+      variable_name = "@#{variable}"
+      actual_value = actual.instance_variable_defined?(variable_name) ? actual.instance_variable_get(variable_name) : nil
+      if actual_value.nil?
+        fail("expected @#{variable} to be assigned a value")
+      elsif !expected_value.nil? && expected_value != actual_value
+        fail(%Q[expected @#{variable} to be equal to #{expected_value.inspect}, not #{actual_value.inspect}])
+      else
+        pass
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/empty.rb

@@ -0,0 +1,13 @@
+module Riot
+  # Asserts the result is empty
+  #   asserts("a string") { "" }.empty
+  #   asserts("an array") { [] }.empty
+  #   asserts("a hash") { Hash.new }.empty
+  class EmptyMacro < AssertionMacro
+    register :empty
+
+    def evaluate(actual)
+      actual.length == 0 ? pass : fail("expected #{actual.inspect} to be empty")
+    end
+  end
+end

data/lib/riot/assertion_macros/equals.rb

@@ -0,0 +1,18 @@
+module Riot
+  # Asserts that the result of the test equals the expected value. Using the +===+ operator to assert
+  # equality.
+  #   asserts("test") { "foo" }.equals("foo")
+  #   should("test") { "foo" }.equals("foo")
+  #   asserts("test") { "foo" }.equals { "foo" }
+  class EqualsMacro < AssertionMacro
+    register :equals
+
+    def evaluate(actual, expected)
+      if expected === actual
+        pass("is equal to #{expected.inspect}")
+      else
+        fail("expected #{expected.inspect}, not #{actual.inspect}")
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/exists.rb

@@ -0,0 +1,15 @@
+module Riot
+  # Asserts that the result of the test is a non-nil value. This is useful in the case where you don't want
+  # to translate the result of the test into a boolean value
+  #   asserts("test") { "foo" }.exists
+  #   should("test") { 123 }.exists
+  #   asserts("test") { "" }.exists
+  #   asserts("test") { nil }.exists # This would fail
+  class ExistsMacro < AssertionMacro
+    register :exists
+
+    def evaluate(actual)
+      !actual.nil? ? pass("is not nil") : fail("expected a non-nil value")
+    end
+  end
+end

data/lib/riot/assertion_macros/includes.rb

@@ -0,0 +1,17 @@
+module Riot
+  # Asserts the result contains the expected element
+  #   asserts("a string") { "world" }.includes('o')
+  #   asserts("an array") { [1,2,3] }.includes(2)
+  #   asserts("a range") { (1..15) }.includes(10)
+  class IncludesMacro < AssertionMacro
+    register :includes
+
+    def evaluate(actual, expected)
+      if actual.include?(expected)
+        pass("includes #{expected.inspect}")
+      else
+        fail("expected #{actual.inspect} to include #{expected.inspect}")
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/kind_of.rb

@@ -0,0 +1,16 @@
+module Riot
+  # Asserts that the result of the test is an object that is a kind of the expected type
+  #   asserts("test") { "foo" }.kind_of(String)
+  #   should("test") { "foo" }.kind_of(String)
+  class KindOfMacro < AssertionMacro
+    register :kind_of
+
+    def evaluate(actual, expected)
+      if actual.kind_of?(expected)
+        pass("is a kind of #{expected.inspect}")
+      else
+        fail("expected kind of #{expected}, not #{actual.class.inspect}")
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/matches.rb

@@ -0,0 +1,17 @@
+module Riot
+  # Asserts that the result of the test equals matches against the proved expression
+  #   asserts("test") { "12345" }.matches(/\d+/)
+  #   should("test") { "12345" }.matches(/\d+/)
+  class MatchesMacro < AssertionMacro
+    register :matches
+
+    def evaluate(actual, expected)
+      expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
+      if actual =~ expected
+        pass("matches #{expected.inspect}")
+      else
+        fail("expected #{expected.inspect} to match #{actual.inspect}")
+      end
+    end
+  end
+end

data/lib/riot/assertion_macros/nil.rb

@@ -0,0 +1,12 @@
+module Riot
+  # Asserts that the result of the test is nil
+  #   asserts("test") { nil }.nil
+  #   should("test") { nil }.nil
+  class NilMacro < AssertionMacro
+    register :nil
+
+    def evaluate(actual)
+      actual.nil? ? pass("is nil") : fail("expected nil, not #{actual.inspect}")
+    end
+  end
+end