be 0.1.0

data/History.md

@@ -0,0 +1,9 @@
+# Release History
+
+## 0.1.0 / 2012-02-28
+
+This is the first release of Be.
+
+Changes:
+
+* Happy Birthday!

data/License.txt

@@ -0,0 +1,28 @@
+Be - Behavioral Expectations
+
+Copyright (c) 2012 Rubyworks. All rights expressly reserved.
+
+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 HOLDER 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.
+
+(http://spdx.org/licenses/BSD-2-Clause)
+

data/README.md

@@ -0,0 +1,55 @@
+# Be - Behaviorial Expectations
+
+"Oh, Behave!"
+
+[Website](http://rubyworks.github.com.be) /
+[Report Issue](http://github.com/rubyworks/be/issues) /
+[Source Code](http://github.com/rubyworks/be) /
+[Mailing List](http://google.groups.com/groups/rubyworks-mailinglist)
+
+[![Build Status](https://secure.travis-ci.org/rubyworks/be.png)](http://travis-ci.org/rubyworks/be)
+
+
+## Description
+
+Be is a fully versitle, light-weight and BRASS compliant assertions framework
+for Ruby. It utilizes an *assertor* design (*matchers* in RSpec terminology)
+which meshes well with BDD nomenclatures.
+
+
+## Instruction
+
+Be's usage is very simple. It consits of using `#should` with a target object,
+and passing it the reuslt of calling `#be` or `#have` with expectation critera.
+Here is an example:
+
+    require 'be'
+
+    object = "string"
+
+    object.should be.instance_of?(String)
+    object.should have(6).size
+
+The only difference betwee `#be` and `#have` is the default expectation method
+that is used if none is provided. In the base of `#be` it is `#==`, for `#have` 
+it is `#include?`.
+
+    "abc".should be("abc")
+
+    [:a,:b,:c].should have(:b)
+
+Be works on the principle of *assertors*, a type of functor, or higher-order
+function. In RSpec these are know as *matchers*. Be provides the method `#should`
+for all Objects which accepts any object that converts to an assertor via a
+`#to_assertor` method. The `#be` and `#have` method returns just that, a `Be::Delegator`
+which orgnaizes all calls made against it to use as expectations in the `Be::Assertor`.
+
+
+## Copyrights
+
+Copyright (c) 2012 Rubyworks
+
+Be is distributable in accordance with the **FreeBSD** license.
+
+See License.txt for details.
+

data/lib/be.rb

@@ -0,0 +1,6 @@
+require 'be/kernel'
+
+class Object
+  include Be::Kernel
+end
+

data/lib/be/assertor.rb

@@ -0,0 +1,147 @@
+module Be
+
+  # An *assertor* is what RSpec calls a *matcher*.
+  #
+  class Assertor
+
+    #
+    def initialize(messages, criteria={})
+      @messages   = messages
+      @criteria   = criteria
+      @comparator = criteria[:compare] || :==
+    end
+
+    #
+    def pass?(target)
+      result = target
+      @messages.each do |op, args, blk|
+        result = result.__send__(op, *args, &blk)
+      end
+
+      if @criteria.key?(:measure)
+        @criteria[:measure].__send__(@comparator, result)
+      else
+        result
+      end
+    end
+
+    #
+    def fail?(target)
+      ! pass?(target)
+    end
+
+    #
+    def assert!(target)
+      handle(pass?(target), target)
+    end
+
+    #
+    def refute!(target)
+      handle(fail?(target), target)
+    end
+
+    alias_method :==, :pass?
+    alias_method :!=, :fail?
+
+    alias_method :=~,  :assert!
+    alias_method :!~,  :refute! unless RUBY_VERSION < '1.9'
+
+    alias_method :===, :assert!
+
+  private
+
+    #
+    #
+    #
+    def handle(result, target)
+      if result
+        increment_passing
+      else
+        increment_failing
+
+        error_class = Be::ASSERTION_ERRORS[@operator] || StandardError
+
+        msg = assert_message(target) #, @operator, @arguments)
+        err = error_class.new(msg)
+        err.set_backtrace(@criteria[:caller] || caller[2..-1])
+        err.set_assertion(true)
+        raise err
+      end
+    end
+
+    #
+    # Produce an error message.
+    #
+    def assert_message(target)
+      #"#{target.inspect} #{@operator} #{@arguemnts.map{ |x| x.inspect }}"
+
+      s = "b"
+      r = target
+
+      sigs = []
+
+      @messages.each do |meth, args, blk|
+        vars = []
+        list = []
+
+        args.each do |a|
+          vars << s
+          list << "#{s}) " + a.inspect
+          s = s.succ
+        end
+
+        sigs << [meth, vars, list]
+      end
+
+      msgs = []
+      vest = ["a) #{r.inspect}"]
+      sigs.each do |meth, vars, list|
+        msgs << "#{meth}(#{vars.join(', ')})"
+        vest << list.join("\n") unless list.empty?
+      end
+ 
+      "a." + msgs.join(".") + "\n" + vest.join("\n")
+    end
+
+    #
+    #
+    #
+    def refute_message(target)
+      "! " + assert_message(target)
+    end
+
+    #
+    # Increment BRASS standard assertion counts for passing assertion.
+    #
+    def increment_passing
+      $ASSERTION_COUNTS[:total] += 1
+      $ASSERTION_COUNTS[:pass]  += 1
+    end
+
+    #
+    # Increment BRASS standard assertion counts for failing assertion.
+    #
+    def increment_failing
+      $ASSERTION_COUNTS[:total] += 1
+      $ASSERTION_COUNTS[:fail]  += 1
+    end
+
+  public
+
+    # The following methods allow these to work as RSpec matchers.
+
+    # For RSpec matcher compatability.
+    alias_method :matches?, :pass?
+
+    # For RSpec matcher compatability.
+    alias_method :does_not_match?, :fail?
+
+    # For RSpec matcher compatability.
+    alias_method :failure_message_for_should, :assert_message
+
+    # For RSpec matcher compatability.
+    alias_method :failure_message_for_should_not, :refute_message
+
+  end
+
+end

data/lib/be/core_ext.rb

@@ -0,0 +1,8 @@
+class Object
+
+  def identical?(other)
+    object_id == other.object_id
+  end
+
+end
+

data/lib/be/delegator.rb

@@ -0,0 +1,49 @@
+module Be
+
+  # Delegator acts as the go-between between the subjunctive call
+  # and the Assertor.
+  #
+  class Delegator < BasicObject
+
+    #
+    # Initialize new Delegator.
+    #
+    def initialize(criteria={})
+      @criteria = criteria
+      @messages = []
+    end
+
+    #
+    # Convert to Assertor. If `@messages` is empty then
+    # defaults to calling method given by `criteria[:default]`
+    # or `#==` failing that.
+    #
+    def to_assertor
+      if @messages.empty?
+        default  = @criteria.delete(:default) || :==
+        measure  = @criteria.delete(:measure)
+        messages = [[default, [measure], nil]]
+        Assertor.new(messages, @criteria)
+      else
+        Assertor.new(@messages, @criteria)
+      end
+    end
+
+    def method_missing(name, *args, &blk)
+      @messages << [name, args, blk]
+      self
+    end
+
+    def ==(other)
+      @messages << [:==, [other], nil]
+      self
+    end
+
+    def equal?(other)
+      @messages << [:==, [other], nil]
+      self
+    end
+  end
+
+end
+

data/lib/be/errors.rb

@@ -0,0 +1,29 @@
+module Be
+  # Map assertion methods to the Errors that they should raise.
+  #
+  # In the future there is good chance this will depend on the Assay
+  # library instead of defining our own error classes here. However
+  # we'll wait until that library matures further before making that
+  # leap.
+  #
+  ASSERTION_ERRORS = {}
+end
+
+class Exception
+  #
+  def self.be(name)
+    Be::ASSERTION_ERRORS[name.to_sym] = self
+  end
+end
+
+class TypeError
+  be :instance_of?
+  be :kind_of?
+end
+
+class EqualityError < StandardError
+  be :==
+  be :eql?
+  be :equal?
+end
+

data/lib/be/kernel.rb

@@ -0,0 +1,53 @@
+require 'brass'
+
+require 'be/core_ext'
+require 'be/errors'
+require 'be/assertor'
+require 'be/delegator'
+require 'be/should'
+
+module Be
+
+  #
+  module Kernel
+
+    # be
+    #
+    #   "object".should be("object")
+    #   "object".should be.kind_of?(String)
+    #
+    def be(measure=:'n/a')
+      criteria = {
+        :compare => :==,
+        :default => :==,
+        :caller => caller
+      }
+      if measure != :'n/a'
+        criteria[:measure] = measure
+      end
+      Be::Delegator.new(criteria)
+    end
+
+    # have
+    #
+    #   "object".should have('bj')[1..2]
+    #   "object".should have.size == 6
+    #
+    #   "object".should have.size
+    #   "object".should have.member?('j')
+    #
+    def have(measure=:'n/a')
+      criteria = {
+        :compare => :==,
+        :default => :include?,
+        :caller => caller
+      }
+      if measure != :'n/a'
+        criteria[:measure] = measure
+      end
+      Be::Delegator.new(criteria)
+    end
+
+  end
+
+end

data/lib/be/should.rb

@@ -0,0 +1,17 @@
+class Object
+
+  # TODO: Should we also support fluid notation?
+  #   e.g. `[2,4,6].should.include?(4)`
+
+  #
+  def should(assay)
+    assay.to_assertor.assert!(self)
+  end
+
+  #
+  def should_not(assay)
+    assay.to_assertor.refute!(self)
+  end
+
+end
+

data/spec/spec_be.rb

@@ -0,0 +1,42 @@
+describe "be method" do
+
+  it "should return a BeDelegator" do
+    assert Be::Delegator === be
+  end
+
+  it "should return a BeDelegator with argument" do
+    assert Be::Delegator === be('string')
+  end
+
+  it "should return a BeDelegator when method called" do
+    assert Be::Delegator === be.anything
+  end
+
+  it "should return a BeDelegator with argument and method called" do
+    assert Be::Delegator === be('something').anything
+  end
+
+  it "should work as assert equal when measure is given" do
+    "string".should be('string')
+    "string".should_not be('something else')
+  end
+
+  it "should assert equal when measure is geiven and method is called" do
+    "string".should be('STRING').upcase
+  end
+
+  it "should assert queries, such as instance_of?" do
+    "string".should be.instance_of?(String)
+    "string".should_not be.instance_of?(Integer)
+  end
+
+  it "should assert operator queries such as ==" do
+    "string".should be == 'string'
+  end
+
+  it "should assert for any lenght method chain" do
+    "string".should be.upcase == 'STRING'
+  end
+
+end
+

data/spec/spec_have.rb

@@ -0,0 +1,41 @@
+describe "have method" do
+
+  it "should return a to have delegator" do
+    assert Be::Delegator === have
+  end
+
+  it "with argument should return a HaveAssertor" do
+    assert Be::Delegator === have('string')
+  end
+
+  it "should delegate and return an assertor" do
+    assert Be::Delegator === have.anything
+  end
+
+  it "should defualt to #include? by default" do
+    [1,2,3].should have(2)
+  end
+
+  it "should work to assert #size" do
+    "string".should have(6).size
+    "string".should have.size == 6
+  end
+
+  it "should work to refute #size" do
+    "string".should_not have(7).size
+    "string".should_not have.size == 7
+  end
+
+  it "should assert query methods" do
+    "string".should have.include?('r')
+    [1,2,3].should have.member?(1)
+  end
+
+  it "should handle method chains" do
+    assert(Be::Delegator === have.size.to_s)
+
+    "string".should have.size.to_s == '6'
+  end
+
+end
+

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: be
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Trans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ansi
+  requirement: &16389760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16389760
+- !ruby/object:Gem::Dependency
+  name: brass
+  requirement: &16383740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16383740
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &16382620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16382620
+- !ruby/object:Gem::Dependency
+  name: spectroscope
+  requirement: &16381300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *16381300
+description: ! 'Be (Behavioral expectations) is a fully versitle, light-weight and
+  BRASS
+
+  compliant assertions framework for Ruby. It utilizes an *assertor* design
+
+  (*matchers* in RSpec terminology) which meshes well with BDD nomenclatures.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- License.txt
+- README.md
+- History.md
+files:
+- lib/be/assertor.rb
+- lib/be/core_ext.rb
+- lib/be/delegator.rb
+- lib/be/errors.rb
+- lib/be/kernel.rb
+- lib/be/should.rb
+- lib/be.rb
+- spec/spec_be.rb
+- spec/spec_have.rb
+- README.md
+- History.md
+- License.txt
+homepage: http://rubyworks.github.com/be
+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.11
+signing_key: 
+specification_version: 3
+summary: Behavior Expressive
+test_files: []