rspecial 0.3.0

data/.index

@@ -0,0 +1,61 @@
+---
+type: ruby
+revision: 2013
+sources:
+- var
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+organizations: []
+requirements:
+- name: assay
+- groups:
+  - build
+  development: true
+  name: detroit
+- groups:
+  - test
+  development: true
+  name: qed
+conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/rspecial
+  label: Homepage
+- type: docs
+  uri: http://rubydoc.info/gems/rspecial
+  label: Documentation
+- type: code
+  uri: http://github.com/rubyworks/rspecial
+  label: Source Code
+- type: mail
+  uri: http://groups.google.com/groups/rubyworks-mailinglist
+  label: Mailing List
+- type: chat
+  uri: http://chat.us.feenode.net/rubyworks
+  label: IRC Channel
+repositories:
+- name: upstream
+  scm: git
+  uri: git@github.com:rubyworks/rspecial.git
+categories: []
+load_path:
+- lib
+copyrights:
+- holder: Rubyworks
+  year: '2012'
+  license: BSD-2-Clause
+created: '2012-01-18'
+summary: Brass-balled RSpec Expectations
+title: RSpecial
+version: 0.3.0
+name: rspecial
+description: ! 'RSpecial defines a set of RSpec-compatible matcher methods which
+
+  are BRASS compliant by using Assay as a backend. This allows developers
+
+  to switch to BRASS compliant test frameworks without having to change
+
+  a slew of previously written RSpec-based specifications.'
+date: '2012-12-12'

data/.ruby

@@ -0,0 +1 @@
+ruby 1.9.3p327 (2012-11-10 revision 37606) [x86_64-linux]

data/DEMOS.md

@@ -0,0 +1,269 @@
+# RSpecish
+
+## Setup
+
+First we need to require the library.
+
+  require 'rspecish'
+
+This will load Assay and the RSpec extension, which will add `#should`
+and `#should_not` to `BasicObject` class, and create a module called
+`RSpecish::Matchers`. This moudle is included into `Assay::Matchers`.
+To make use of it, we simply need to include either of these modules into
+our test scope.
+
+  include ::Assay::Matchers
+
+With that in place, we are ready to use the matchers.
+
+
+## RSpec Should Method
+
+### should
+
+Becuase the `#should` method used `=~` as the assertion operator,
+you can do something a bit unexpected, such as,
+
+    'a'.should /a/
+
+
+### should=
+
+    10.should = 10
+
+    expect ::EqualAssay do
+      10.should = 20
+    end
+
+    10.should_not = 20
+
+
+## RSpec Matchers
+
+### should equal
+
+  1.should = 1
+
+  expect ::EqualAssay do
+    1.should = 2
+  end
+
+### be_true
+
+  true.should be_true
+
+  expect ::TrueAssay do
+    false.should be_true
+  end
+
+### be_false
+
+  false.should be_false
+
+  expect ::FalseAssay do
+    true.should be_false
+  end
+
+### be_nil
+
+  nil.should be_nil
+
+  expect ::NilAssay do
+    true.should be_nil
+  end
+
+### be_empty
+
+  [].should be_empty
+
+  expect ::EmptyAssay do
+    [1].should be_empty
+  end
+
+  [1].should_not be_empty
+
+### be_close
+
+  1.should be_close(1.5, 2)
+
+  expect ::WithinAssay do
+    1.should be_close(0.5, 2)
+  end
+
+  1.should_not be_close(0.5, 2)
+
+### match
+
+  "abc".should match(/a/)
+
+  expect ::MatchAssay do
+    "abc".should match(/x/)
+  end
+
+  "abc".should_not match(/g/)
+
+### eql
+
+  1.should eql(1)
+
+  expect ::EqualityAssay do
+    1.should eql(1.0)
+  end
+
+  1.should_not eql(1.0)
+
+### equal
+
+  :a.should equal(:a)
+
+  expect ::IdentityAssay do
+    "a".should equal("a")
+  end
+
+  :a.should_not equal('a')
+
+### be_instance_of
+
+  1.should be_instance_of(Fixnum)
+
+  expect ::InstanceAssay do
+    1.should be_instance_of(String)
+  end
+
+  1.should_not be_instance_of(String)
+
+### be_kind_of
+
+  1.should be_kind_of(Integer)
+
+  expect ::KindAssay do
+    1.should be_kind_of(String)
+  end
+
+  1.should_not be_kind_of(String)
+
+### raise_error
+
+  procedure = lambda{ raise ::ArgumentError }
+
+  procedure.should raise_error(::ArgumentError)
+
+  expect ::RaiseAssay do
+    procedure.should raise_error(::TypeError)
+  end
+
+  procedure.should_not raise_error(::TypeError)
+
+### respond_to
+
+  "string".should respond_to(:upcase)
+
+  expect ::RespondAssay do
+    "string".should respond_to(:not_a_method)
+  end
+
+  "string".should_not respond_to(:not_a_method)
+
+### satisfy
+
+  5.should satisfy{ |x| x > 3 }
+
+  expect ::ExecutionAssay do
+    5.should satisfy{ |x| x < 3 }
+  end
+
+  5.should_not satisfy{ |x| x < 3 }
+
+### throw_symbol
+
+  procedure = lambda{ throw :foo }
+
+  procedure.should throw_symbol(:foo)
+
+  expect ::ThrowAssay do
+    procedure.should throw_symbol(:bar)
+  end
+
+  procedure.should_not throw_symbol(:bar)
+
+## Supplemental Matchers
+
+### equate_to
+
+This is not strictly an RSpec matcher, but we have thrown it in for good measure.
+It is equivalent to using the `#should=` method.
+
+  10.should equate_to(10)
+
+  expect ::EqualityAssay do
+    10.should equate_to(10.0)
+  end
+
+  10.should_not equate_to(10.0)
+
+### be_like
+
+The `#be_like` matcher is not strictly an RSpec matcher, but we have thrown it
+in for good measure.
+
+  /a/.should be_like('a')
+
+  expect ::LikeAssay do
+    /a/.should be_like('b')
+  end
+
+  /a/.should_not be_like('b')
+
+
+### Have
+
+The `#have` matchers make it easy to set expectations about the size
+of a collection. In general the term `items` is used if the target
+object is a collection.
+
+    a = [1, 2, 3]
+
+    a.should have(3).items
+    a.should_not have(2).items
+    a.should_not have(4).items
+
+    a.should have_exactly(3).items
+    a.should_not have_exactly(2).items
+    a.should_not have_exactly(4).items
+
+    a.should have_at_least(2).items
+    a.should have_at_most(4).items
+
+But a method that returns a collection can be used instead.
+
+    class String
+      def words
+        split(' ')
+      end
+    end
+
+    s = "a sentence with some words"
+
+    s.should have(5).words
+    s.should_not have(4).words
+    s.should_not have(6).words
+
+    s.should have_exactly(5).words
+    s.should_not have_exactly(4).words
+    s.should_not have_exactly(6).words
+
+    s.should have_at_least(4).words
+    s.should have_at_most(6).words
+
+Besides `#have` there is also `#have_at_least` and `#have_at_most`.
+
+    a = [1, 2, 3]
+
+    a.should have_at_least(2).items
+    a.should have_at_most(4).items
+
+    a.should have_at_least(3).items
+    a.should have_at_most(3).items
+
+
+

data/HISTORY.md

@@ -0,0 +1,31 @@
+# HISTORY
+
+## 0.3.0 | 2012-03-16
+
+Renamed project from *Assay RSpec* to *RSpecial*, and added
+RSpec's new expect notation.
+
+Changes:
+
+* Rename project to respecial.
+* Add RSpec's new expect notation. 
+
+
+## 0.2.0 | 2012-02-26
+
+This release adds support for #have matchers.
+
+Changes:
+
+* Add support for have matchers.
+
+
+## 0.1.0 | 2012-01-26
+
+This is the initial release of Assay RSpec. Currently the library covers
+every RSpec matcher except the `change` and `have` matchers.
+
+Changes:
+
+* Happy Birthday!
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+BSD-2-Clause License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,76 @@
+# RSpecial
+
+[Homepage](http://rubyworks.github.com/rspecial) /
+[Report Issue](http://github.com/rubyworks/rspecial/issues) /
+[Source Code](http://github.com/rubyworks/rspecial)
+( [![Build Status](https://secure.travis-ci.org/rubyworks/rspecial.png)](http://travis-ci.org/rubyworks/rspecial) )
+
+_Well, isn't that special._
+
+<br/>
+
+RSpecial is an BRASS-compliant *assertions framework*. It defines
+the RSpec's `expect` and `should` handlers and a set of RSpec-compatible matchers
+allowing developers to change test frameworks without having to change
+a slew of previously defined assertions.
+
+RSpecial utilizes the [Assay](http://rubyworks.github.com/assay)
+assertions meta-framework on the back-end. Assay defines assertions
+in the same way that Ruby defines exceptions. An assertion is nothing
+more that an extended Exception class. Assay provides a complete set
+of these assertion classes for all common assertion needs.
+
+
+## Installation
+
+To install with RubyGems simply open a console and type:
+
+    $ gem install rspecial
+
+Old-school site installations via a tarball can be done with [Ruby Setup](http://rubyworks.github.com/setup)
+(`gem install setup`).
+
+
+## Basic Usage
+
+To use RSpecial, simply require the `rspecial` script, and include the `RSpecial::Matchers`
+or `Test::Matchers` mixin module into your test framework wherever it requires
+it (which may be as simple as the top-level namespace).
+
+    require 'rspecial'
+
+    include RSpecial::Matchers
+
+Or more generically,
+
+    include Test::Matchers
+
+Now assertions can be made just as if you were using RSpec.
+
+    expect(10).to be_kind_of(Integer)
+    
+and the traditional way
+
+    10.should be_kind_of(Integer)
+
+
+## Limitations
+
+Compatibility with RSpec is not 100%, but it is close. Compatibility will improve
+with future releases.
+
+Also error messages aren't always as nice, nor always customizable, as they are in RSpec.
+This too will improve with future releases.
+
+Please feel _obligated_ to submit a patch if you need a missing a feature ;-)
+
+
+## Copyrights
+
+RSpecial is copyright open source software 
+
+    Copyright (c) 2012 Rubyworks
+
+This program is distributed under the terms of the [BSD-2-Clause](http://spdx.org/licenses/BSD-2-Clause) license.
+
+See LICENSE.txt file for details.

data/lib/assay/rspec.rb

@@ -0,0 +1 @@
+require 'rspecial'

data/lib/rspecial.rb

@@ -0,0 +1,20 @@
+# RSpecial (http://rubyworks.github.com/rspecial)
+# Copyright (c) 2012 Rubyworks.
+# License (spdx) BSD-2-Clause.
+
+require 'assay'
+require 'rspecial/matchers'
+require 'rspecial/have'
+require 'rspecial/should'
+require 'rspecial/expect'
+require 'rspecial/operatics'
+
+# This Test::Matchers module holds all matcher methods, which can be mixed into
+# one's testing scope (e.g. World).
+#
+module Test
+  module Matchers
+    include RSpecial::Matchers
+  end
+end
+

data/lib/rspecial.yml

@@ -0,0 +1,61 @@
+---
+type: ruby
+revision: 2013
+sources:
+- var
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+organizations: []
+requirements:
+- name: assay
+- groups:
+  - build
+  development: true
+  name: detroit
+- groups:
+  - test
+  development: true
+  name: qed
+conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/rspecial
+  label: Homepage
+- type: docs
+  uri: http://rubydoc.info/gems/rspecial
+  label: Documentation
+- type: code
+  uri: http://github.com/rubyworks/rspecial
+  label: Source Code
+- type: mail
+  uri: http://groups.google.com/groups/rubyworks-mailinglist
+  label: Mailing List
+- type: chat
+  uri: http://chat.us.feenode.net/rubyworks
+  label: IRC Channel
+repositories:
+- name: upstream
+  scm: git
+  uri: git@github.com:rubyworks/rspecial.git
+categories: []
+load_path:
+- lib
+copyrights:
+- holder: Rubyworks
+  year: '2012'
+  license: BSD-2-Clause
+created: '2012-01-18'
+summary: Brass-balled RSpec Expectations
+title: RSpecial
+version: 0.3.0
+name: rspecial
+description: ! 'RSpecial defines a set of RSpec-compatible matcher methods which
+
+  are BRASS compliant by using Assay as a backend. This allows developers
+
+  to switch to BRASS compliant test frameworks without having to change
+
+  a slew of previously written RSpec-based specifications.'
+date: '2012-12-12'

data/lib/rspecial/expect.rb

@@ -0,0 +1,151 @@
+module RSpecial
+
+  # Wraps the target of an expectation.
+  #
+  # @example
+  #   expect(something) # => Expect
+  #
+  #   # used with `to`
+  #   expect(actual).to eq(3)
+  #
+  #   # with `to_not`
+  #   expect(actual).to_not eq(3)
+  #
+  class Expect
+
+    # @api private
+    def initialize(target)
+      @target = target
+    end
+
+    # Runs the given expectation, passing if `matcher` returns true.
+    #
+    # @example
+    #   expect(value).to eq(5)
+    #   expect { perform }.to raise_error
+    #
+    # @param [Matcher]
+    #   matcher
+    #
+    # @param [String] message optional message to display when the expectation fails
+    #
+    # @return [Boolean] true if the expectation succeeds (else raises)
+    #
+    # @see RSpec::Matchers
+    #
+    def to(matcher=nil, message=nil, &block)
+      #prevent_operator_matchers(:to, matcher)
+      handle_positive_matcher(@target, matcher, message, &block)
+    end
+
+    # Runs the given expectation, passing if `matcher` returns false.
+    #
+    # @example
+    #   expect(value).to_not eq(5)
+    #   expect(value).not_to eq(5)
+    #
+    # @param [Matcher]
+    #   matcher
+    #
+    # @param [String] message optional message to display when the expectation fails
+    #
+    # @return [Boolean] false if the negative expectation succeeds (else raises)
+    #
+    # @see RSpec::Matchers
+    #
+    def to_not(matcher=nil, message=nil, &block)
+      #prevent_operator_matchers(:to_not, matcher)
+      handle_negative_matcher(@target, matcher, message, &block)
+    end
+
+    alias :not_to :to_not
+
+  private
+
+    #def prevent_operator_matchers(verb, matcher)
+    #  return if matcher
+    #
+    #  raise ArgumentError, "The expect syntax does not support operator matchers, " +
+    #                       "so you must pass a matcher to `##{verb}`."
+    #end
+
+    #
+    # @todo how to customize the message?
+    #
+    def handle_positive_matcher(actual, matcher, message=nil, &block)
+      check_message(message)
+
+      #::RSpec::Matchers.last_should = :should
+      #::RSpec::Matchers.last_matcher = matcher
+
+      if block
+        actual = block.call(actual)
+      end
+
+      #return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+      return Operatics.new(actual) if matcher.nil?
+
+      matcher =~ actual
+
+      #match = matcher.matches?(actual, &block)
+      #return match if match
+
+      #message ||= matcher.respond_to?(:failure_message_for_should) ?
+      #            matcher.failure_message_for_should :
+      #            matcher.failure_message
+
+      #if matcher.respond_to?(:diffable?) && matcher.diffable?
+      #  ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+      #else
+      #  ::RSpec::Expectations.fail_with message
+      #end
+    end
+
+    #
+    # @todo how to customize the message?
+    #
+    def handle_negative_matcher(actual, matcher, message=nil, &block)
+      check_message(message)
+
+      #::RSpec::Matchers.last_should = :should_not
+      #::RSpec::Matchers.last_matcher = matcher
+
+      if block
+        actual = block.call(actual)
+      end
+
+      #return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
+
+      return Operatics.new(actual, true) if matcher.nil?
+
+      matcher !~ actual
+
+      #match = matcher.respond_to?(:does_not_match?) ?
+      #        !matcher.does_not_match?(actual, &block) :
+      #        matcher.matches?(actual, &block)
+      #return match unless match
+
+      #message ||= matcher.respond_to?(:failure_message_for_should_not) ?
+      #            matcher.failure_message_for_should_not :
+      #            matcher.negative_failure_message
+
+      #if matcher.respond_to?(:diffable?) && matcher.diffable?
+      #  ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+      #else
+      #  ::RSpec::Expectations.fail_with message
+      #end
+    end
+
+    def message_must_be_string(msg)
+      "WARNING: ignoring the provided expectation message argument " +
+      "(#{msg.inspect}) since it is not a string."
+    end
+
+    def check_message(msg)
+      ::Kernel.warn message_must_be_string(msg) unless msg.nil? || msg.is_a?(String)
+    end
+
+  end
+
+end

data/lib/rspecial/have.rb

@@ -0,0 +1,201 @@
+module RSpecial
+
+  # Delegate to Have Assays.
+  #
+  class Have
+
+    attr :expected
+
+    attr :collection_name
+
+    attr :relation
+
+    #
+    # Initialize new Have delegator.
+    #
+    def initialize(expected, relation=:exactly)
+      @expected = case expected
+                  when :no then 0
+                  when String then expected.to_i
+                  else expected
+                  end
+      @relation        = relation
+      @collection_name = nil
+    end
+
+    #
+    # @param [#size,#length,#count] collection_or_owner
+    #
+    def collection(collection_or_owner)
+      if collection_or_owner.respond_to?(@collection_name)
+        collection_or_owner.__send__(@collection_name, *@args, &@block)
+      elsif query_method(collection_or_owner)
+        collection_or_owner
+      else
+        collection_or_owner.__send__(@collection_name, *@args, &@block)
+      end
+    end
+
+    #
+    #
+    #
+    def query_method(collection)
+      [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+    end
+
+    #
+    #
+    #
+    def method_missing(method, *args, &block)
+      @collection_name = method
+      @args  = args
+      @block = block
+
+      case @relation
+      when :at_least
+        RSpecial::HaveAtLeastAssay.assertor(self)
+      when :at_most
+        RSpecial::HaveAtMostAssay.assertor(self)
+      else
+        RSpecial::HaveExactlyAssay.assertor(self)
+      end
+    end
+
+    #
+    #
+    module Helpers
+
+      #
+      #
+      #
+      def collection_set(collection_or_owner, have)
+        collection   = have.collection(collection_or_owner)
+        query_method = query_method(collection)
+
+        raise not_a_collection(have) unless query_method
+
+        actual = collection.__send__(query_method)
+
+        return collection, query_method, actual
+      end
+
+      #
+      # Return the actual size of the collection.
+      #
+      def collection_actual(collection_or_owner, have)
+        collection_set(collection_or_owner, have).last
+      end
+
+      #
+      # Which size method to use: `size`, `length` or `count`.
+      #
+      def query_method(collection)
+        [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+      end
+
+      #
+      # Message to use when collection doesn't respond to `size`, `length` or `count`.
+      #
+      def not_a_collection(have)
+        "expected #{have.collection_name} to be a collection but it does not respond to #length, #size or #count"
+      end
+
+      #
+      # TODO: use when verbose error message mode
+      #
+      def self.assert_description(collection_or_owner, have)
+        collection, method, actual = collection_set(collection_or_owner, have)
+        "expected #{have.relation} #{have.expected} #{have.collection_name}, got #{actual}"
+      end
+
+      #
+      #
+      #
+      def self.refute_descrptipon(collection_or_owner, have)
+        collection, method, actual = collection_set(collection_or_owner, have)
+        "expected not to have #{have.relation} #{have.expected} #{have.collection_name}, got #{actual}"
+      end
+
+    end
+
+  end
+
+  #
+  #
+  class HaveExactlyAssay < EqualAssay
+
+    extend Have::Helpers
+
+    register :have
+
+    #
+    #
+    #
+    def self.pass?(collection_or_owner, have)
+      actual = collection_actual(collection_or_owner, have)
+      super(actual, have.expected)
+    end
+
+    #
+    # Error message for have equal assertion.
+    #
+    def self.assert_message(collection_or_owner, have)
+      actual = collection_actual(collection_or_owner, have)
+      super(actual, have.expected)
+    end
+
+  end
+
+  #
+  #
+  class HaveAtLeastAssay < MoreEqualAssay
+
+    extend Have::Helpers
+
+    register :have_at_least
+
+    #
+    #
+    #
+    def self.pass?(collection_or_owner, have)
+      actual = collection_actual(collection_or_owner, have)
+      super(actual, have.expected)
+    end
+
+    #
+    #
+    #
+    def self.assert_message(collection_or_owner, have)
+      actual = collection_actual(collection_or_owner, have)
+      super(actual, have.expected)
+    end
+
+  end
+  
+  #
+  #
+  class HaveAtMostAssay < LessEqualAssay
+
+    extend Have::Helpers
+
+    register :have_at_most
+
+    #
+    #
+    #
+    def self.pass?(collection_or_owner, have)
+      actual = collection_actual(collection_or_owner, have)
+      super(actual, have.expected)
+    end
+
+    #
+    #
+    #
+    def self.assert_message(collection_or_owner, have)
+      actual = collection_actual(collection_or_owner, have)
+      super(actual, have.expected)
+    end
+
+  end
+
+end

data/lib/rspecial/matchers.rb

@@ -0,0 +1,258 @@
+module RSpecial
+
+  # This module provides matchers for RSpec-compatiblity.
+  #
+  # The set is not fully compataible, but provides most RSpec matchers.
+  # The most notable exlusion for the moment is the `have` matchers.
+  #
+  # Compatability will improve with time. Feel _obligated_ to submit a
+  # patch if you really need it. ;)
+  #
+  # @see https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+  #
+  module Matchers
+
+    #def self.included(base)
+    #  @_once ||= require_relative('should').nil?
+    #end
+
+    #def self.extended(base)
+    #  @_once ||= require_relative('should').nil?
+    #end
+
+    # Passes if the expected and actual are alike.
+    #
+    #   object.should be_like(criterion)
+    #
+    # There is no equivalant for this in RSpec, we simply add it
+    # here to cover all Assays available.
+    #
+    # @raise LikeAssay
+    #
+    def be_like(criterion)
+      LikeAssay.assertor(criterion)
+    end
+
+    # Passes if expected and actual are nto equal within delta tolerance.
+    #
+    #   value.should be_close(delta, criterion)
+    #
+    # @raise WithinAssay
+    #
+    def be_close(delta, criterion)
+      WithinAssay.assertor(criterion, delta)
+    end
+
+    # Passes if object is empty.
+    #
+    #   object.should be_empty
+    #
+    # @raise EmptyAssay
+    #
+    def be_empty
+      EmptyAssay.assertor
+    end
+
+    # Passes if +expected+ == +actual+.
+    #
+    #   'MY STRING'.should equate_to('my string'.upcase)
+    #   'MY STRING'.should_not equate_to('another string')
+    #
+    # This matcher is not supported by RSpec, but is added so that the
+    # EqualityAssay has an explict matcher available.
+    #
+    # @raise EqualityAssay
+    #
+    def equate_to(exp)
+      EqualityAssay.assertor(exp)
+    end
+
+    #
+    # Passes if block is satisfied given target object as argument.
+    #
+    #   5.should satisfy{ |n| n > 3}
+    #
+    # @raise ExecutionAssay
+    #
+    def satisfy(&block)
+      ExecutionAssay.assertor(&block)
+    end
+
+    #
+    # Passed if object is +false+.
+    #
+    #   value.should be_false
+    #
+    # @raise FalseAssay
+    #
+    def be_false
+      FalseAssay.assertor
+    end
+
+    #
+    # Passes if actual is the same exact object as expected.
+    #
+    #   object.should be_identical_to(object)
+    #
+    # @raise IdentityAssay
+    #
+    def equal(obj)
+      IdentityAssay.assertor(obj)
+    end
+
+    alias :be_identical_to :equal
+
+    #
+    # Passes if `actual == expected`.
+    #
+    #   object.should eq(object)
+    #
+    # @raise EqualAssay
+    #
+    def eq(obj)
+      EqualAssay.assertor(obj)
+    end
+
+    #
+    # Passes if object is an instance of class.
+    #
+    #   object.should be_instance_of(class)
+    #
+    # @raise InstanceAssay
+    #
+    def be_instance_of(cls)
+      InstanceAssay.assertor(cls)
+    end
+
+    alias :be_an_instance_of :be_instance_of
+
+    #
+    # Pass if object is a kind of class.
+    #
+    #   object.should be_kind_of(class)
+    #
+    # @raise KindAssay
+    #
+    def be_kind_of(cls)
+      KindAssay.assertor(cls)
+    end
+
+    alias :be_a_kind_of :be_kind_of
+    alias :be_a         :be_kind_of
+    alias :be_an        :be_kind_of
+
+    #
+    # Pass if object matches pattern using `#=~` method.
+    #
+    #   object.should match(regexp)
+    #
+    # @raise MatchAssay
+    #
+    def match(regexp)
+      MatchAssay.assertor(regexp)
+    end
+
+    #
+    # Pass if object is +nil+.
+    #
+    #   value.should be_nil
+    #
+    # @raise NilAssay
+    #
+    def be_nil
+      NilAssay.assertor
+    end
+
+    #
+    # Pass if an exception is raised.
+    #
+    #   lambda { do_something_risky }.should raise_error
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
+    #
+    # @raise RaiseAssay
+    #
+    # @todo Support for message matching ?
+    #
+    def raise_error(exception=Exception)
+      RaiseAssay.assertor(exception)
+    end
+
+    #
+    # Pass if object responds to message.
+    #
+    #   object.should respond_to(:method_name)
+    #
+    # @raise RespondAssay
+    #
+    def respond_to(method)
+      RespondAssay.assertor(method)
+    end
+
+    #
+    # Pass if two objects are equal using `#eql?` method.
+    #
+    #   object1.should eql(object2)
+    #
+    # @raise EqualityAssay
+    #
+    def eql(exp)
+      EqualityAssay.assertor(exp)
+    end
+
+    #
+    # Pass if procedure throws a specified symbol.
+    #
+    #   lambda { do_something_risky }.should throw_symbol
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #
+    # @raise ThrowAssay
+    #
+    # @todo Support for throw argument. (Does RSpec even support this?)
+    #
+    def throw_symbol(sym=nil) #, arg=nil)
+      ThrowAssay.assertor(sym)
+    end
+
+    #
+    # Passed if object is +true+.
+    #
+    #   object.should be_true
+    #
+    # @raise TrueAssay
+    #
+    def be_true
+      TrueAssay.assertor
+    end
+
+    #
+    #
+    #
+    def have(n)
+      Have.new(n)
+    end
+
+    alias :have_exactly :have
+
+    #
+    #
+    #
+    def have_at_least(n)
+      Have.new(n, :at_least)
+    end
+
+    #
+    #
+    #
+    def have_at_most(n)
+      Have.new(n, :at_most)
+    end
+
+    #
+    #
+    def expect(target)
+      Expect.new(target)
+    end
+
+  end
+
+end

data/lib/rspecial/operatics.rb

@@ -0,0 +1,57 @@
+module RSpecial
+
+  # Operatics delegates operator based assertions for execpt.rb.
+  #
+  class Operatics < Object
+    instance_methods.each{ |m| undef_method m if m.to_s =~ /^\W/ }
+
+    #
+    def initialize(target, negate=false)
+      @target = target
+      @negate = negate
+    end
+
+  private
+
+    #
+    def method_missing(op, *a, &b)
+      super(op, *a, &b) if op.to_s =~ /^\w/
+
+      if @negate
+        refute!(op, *a, &b)
+      else
+        assert!(op, *a, &b)
+      end
+    end
+
+    #
+    def assert!(op, *a, &b)
+      if assay = Assertion.by_operator(op)
+        return assay.assert!(@target, *a, &b)
+      else
+        assert! @target.send(op, *a, &b)
+      end
+    end
+
+    #
+    def refute!(op, *a, &b)
+      if assay = Assertion.by_operator(op)
+        return assay.refute!(@target, *a, &b)
+      else
+        refute! @target.send(op, *a, &b)
+      end
+    end
+
+    #
+    def generic?(op)
+      @target.method(op).owner == ::Kernel
+    end if ::Method.method_defined?(:owner)
+
+    #
+    def generic?(op)
+      @target.method(op).to_s.include?('(Kernel)')
+    end unless ::Method.method_defined?(:owner)
+
+  end
+
+end

data/lib/rspecial/should.rb

@@ -0,0 +1,49 @@
+module RSpecial
+
+  # The Should module is included into BasicObject to provide 
+  # the needed assertion interface that RSpec utilizes. Namely, the
+  # `should` and `should_not` methods.
+  #
+  module Should
+
+    #
+    # Use `should` nomenclature for assertions.
+    #
+    #  10.should be_kind_of(Integer)
+    #
+    def should(matcher)
+      matcher =~ self
+    end
+
+    #
+    # Also, `should_not` nomenclature for assertions.
+    #
+    #  10.should_not be_kind_of?(Integer)
+    #
+    def should_not(matcher)
+      matcher !~ self
+    end
+
+    #
+    #
+    # 
+    def should=(value)
+      EqualAssay.assert!(self, value)
+    end
+
+    #
+    #
+    #
+    def should_not=(value)
+      EqualAssay.refute!(self, value)
+    end
+
+  end
+
+end
+
+
+class BasicObject  # Object ?
+  include ::RSpecial::Should
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: rspecial
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: assay
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'RSpecial defines a set of RSpec-compatible matcher methods which
+
+  are BRASS compliant by using Assay as a backend. This allows developers
+
+  to switch to BRASS compliant test frameworks without having to change
+
+  a slew of previously written RSpec-based specifications.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- HISTORY.md
+- README.md
+- DEMOS.md
+files:
+- .index
+- .ruby
+- lib/assay/rspec.rb
+- lib/rspecial/expect.rb
+- lib/rspecial/have.rb
+- lib/rspecial/matchers.rb
+- lib/rspecial/operatics.rb
+- lib/rspecial/should.rb
+- lib/rspecial.rb
+- lib/rspecial.yml
+- HISTORY.md
+- README.md
+- DEMOS.md
+- LICENSE.txt
+homepage: http://rubyworks.github.com/rspecial
+licenses:
+- BSD-2-Clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Brass-balled RSpec Expectations
+test_files: []