bang 0.1.0

data/COPYING.md

@@ -0,0 +1,36 @@
+# COPYRIGHT
+
+## NOTICES
+
+### Assay
+
+| Project   | Bang                              |
+|-----------|-----------------------------------|
+| Copyright | (c) 2012 Rubyworks                |
+| License   | (r) BSD-2-Clause                  |
+| Website   | http://rubyworks.github.com/bang  |
+
+## LICENSES
+
+### 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/HISTORY.md

@@ -0,0 +1,10 @@
+# HISTORY
+
+## 0.1.0 | 2012-02-09
+
+This is the initial release of Bang.
+
+Changes:
+
+* Happy Birthday!
+

data/README.md

@@ -0,0 +1,63 @@
+# Bang! Bang!
+
+[Website](http://rubyworks.github.com/bang) /
+[Report Issue](http://github.com/rubyworks/bang/issues) /
+[Mailing List](http://groups.google.com/groups/rubyworks-mailinglist) /
+[Source Code](http://github.com/rubyworks/bang) /
+IRC #rubyworks
+
+[![Build Status](https://secure.travis-ci.org/rubyworks/bang.png)](http://travis-ci.org/rubyworks/bang)
+
+
+## Description
+
+Bang! Bang! is an assertions framework with a very clever design that translates
+any bang call, e.g. `#foo!` into an assertion based on the corresponding query
+call, `#foo?` (if it exists). In practice the framework is similar to MiniTest's
+spec expectation methods, e.g. `#must_equal`, but the dynamic nature of Bang!
+Bang! makes it much more flexible, as it is not limited to a finite set of 
+assertion methods.
+
+It's also pretty interesting idea that bang methods are asseriton methods.
+In usual Ruby code, bang methods ususually aren't particularly necessary and 
+could just as well be handled by non-bang methods, e.g. `#update` vs `#merge!`.
+
+
+## Instruction
+
+Usage is pretty straight forward.
+
+    require 'bang'
+
+    "This string".equals!("That string")  #=> raises Bang::Assertion
+
+To use Bang! Bang! most effectively with common test frameworks, you may need
+to load an adapter to ensure the framework recognizes the assertions as
+such rather than as ordinary errors.
+
+For MiniTest use:
+
+    require 'bang/minitest'`
+
+For TestUnit use:
+
+    require 'bang/testunit'
+
+An RSpec adapter is in the works.
+
+Cucumber does not require an adapter as it does not differntiate errors
+from assertions.
+
+Note, these adapters simply require the `brass/adapters/minitest` and
+`brass/adapters/testunit` respecitvely along with `bang`. So that's another
+way to do it too.
+
+
+## Copyrights
+
+Bang Bang is Copyright (c) 2012 Rubyworks
+
+You can redistribute it in accordance to the *BSD-2-Clause* license.
+
+Please see the included COPYING.md file for license details.
+

data/lib/bang.rb

@@ -0,0 +1,350 @@
+module Bang
+
+  if RUBY_VERSION < '1.9'
+    require 'bang/version'
+  else
+    require_relative 'bang/version'
+  end
+
+  # Bang's assertion class. Follows standard set by Brass project,
+  # defining `#assertion?` method which return `true`.
+  #
+  class Assertion < ::Exception
+
+    #
+    # Price together an Assetion error give the message used to 
+    # cause the assertion failure.
+    #
+    # @return [Assertion] Assertion instance.
+    #
+    def self.piece(s, a, b, t)
+      e = new(message(s, *a, &b))
+      e.set_backtrace(t)
+      e
+    end
+
+    #
+    # Put together an error message representive of the assertion made.
+    #
+    # @todo Imporve this to better handle operators.
+    #
+    # @return [String] Failed assertion message.
+    #
+    def self.message(s, *a, &b)
+      "#{s}(%s)" % a.map{ |e| e.inspect }.join(',')
+    end
+
+    #
+    # Bang::Assertion is alwasy an assertion.
+    #
+    # @return [true] Always true.
+    #
+    def assertion?
+      true
+    end
+  end
+
+  # Mixin of Object class, will take any undefined bang method, e.g. `foo!`
+  # and if there is a corresponding query method, e.g. `foo?`, then it will
+  # utilize the query method to make an assertion.
+  #
+  module MethodMissing
+
+    #
+    # If missing method is a bang method, see if there is a corresponding query
+    # method and use that to make an assertion. Will also recognize the same
+    # prefixed by `not_`, e.g. `not_equal_to?`.
+    #
+    def method_missing(s, *a, &b)
+      return super(s, *a, &b) unless s.to_s.end_with?('!')
+
+      neg  = false
+      name = s.to_s.chomp('!')
+
+      if name.start_with?('not_')
+        neg  = true
+        name = name[4..-1]
+      end
+
+      meth = method("#{name}?") rescue nil
+
+      return super(s, *a, &b) unless meth
+
+      result = meth.call(*a, &b)
+
+      if !(neg ^ result)
+        raise Bang::Assertion.piece(s, a, b, caller)
+      end
+    end
+
+  end
+
+  # Mixin for Object class that adds some very useful query methods.
+  #
+  module ObjectMixin
+
+    #
+    # Is `self` identical with `other`? In other words, do two variables
+    # reference the one and the same object.
+    #
+    # @return [true,false] Whether `self` is identical to `other`.
+    #
+    def identical?(other)
+      other.object_id == object_id
+    end
+
+    #
+    # Query method for `#==`. We have to use the `_to` suffix becuase Ruby
+    # already defines the prepositionless term as a synonym for `#identical?`.
+    # (Hopefully that will change one day.)
+    #
+    # @return [true,false] Whether `self` is equal to `other`.
+    #
+    def equal_to?
+      other == self
+    end
+
+    #
+    # Until we can use `#equal?`, lets make the best of it and offer
+    # the plural form as well.
+    #
+    alias :equals? :equal_to?
+
+    #
+    # Test whether `self` is like `other`. Like is broad equality
+    # measure testing `identical?`, `eql?`, `==` and `===`.
+    #
+    # @todo Should `like?` this include `=~` also?
+    #
+    # @return [true,false] Whether `self` is like `other`.
+    #
+    def like?(other)
+      other.identical?(self) ||
+      other.eql?(self)       ||
+      other.==(self)         ||
+      other.===(self)
+    end
+
+    #
+    # Test whether `other` is a case of `self` via `#===` method.
+    #
+    # @return [true,false] Whether `other` is a case of `self`.
+    #
+    def case?(other)
+      other === self
+    end
+
+    #
+    # Test whether `self` matches `other` via `#=~` method.
+    #
+    # @return [true,false] Whether `self` matches `other`.
+    #
+    def match?(other)
+      other =~ self
+    end
+
+    #
+    # Test whether `self` is the `true` instance.
+    #
+    # @return [true,false] Whether `self` is `true`.
+    #
+    def true?
+      TrueClass === self
+    end
+
+    #
+    # Test whether `self` is the `false` instance.
+    #
+    # @return [true,false] Whether `self` is `false`.
+    #
+    def false?
+      FalseClass === self
+    end
+
+    #
+    # Yield the given block and return `true` if the `self` is throw,
+    # otherwise `false`.
+    #
+    # @return [true,false] Whether `self` was thrown.
+    #
+    def thrown?(&block)
+      pass = true
+      catch(self) do
+        begin
+          yield
+        rescue ArgumentError => err     # 1.9 exception
+          #msg += ", not #{err.message.split(/ /).last}"
+        rescue NameError => err         # 1.8 exception
+          #msg += ", not #{err.name.inspect}"
+        end
+        pass = false
+      end
+      pass
+    end
+
+    #
+    # Yield block and return true if it runs without exception and does not
+    # return `nil` or `false`.
+    #
+    # @return [true,false] True if block succeeds, otherwise false.
+    #
+    def satisfy?(&block)
+      begin
+        block.call(self)
+      rescue
+        false
+      end
+    end
+
+  end
+
+  # Mixin for Numeric class that adds `#within?` and `#close?`.
+  #
+  module NumericMixin
+
+    #
+    # Is this value within a given absolute `delta` of another?
+    #
+    # @return [true,false] True if within absolute delta, otherwise false.
+    #
+    def within?(other, delta)
+      a, b, d = self.to_f, other.to_f, delta.to_f
+
+      (b - d) <= a && (b + d) >= a   
+    end
+
+    #
+    # Is this value within a given relative `epsilon` of another?
+    #
+    # @return [true,false] True if within relative epsilon, otherwise false.
+    #
+    def close?(other, epsilon)
+      a, b, e = self.to_f, other.to_f, epsilon.to_f
+
+      d = b * e
+
+      (b - d) <= a && (b + d) >= a
+    end
+
+  end
+
+  # Mixin for Proc class that adds `#raises?`, `#rescues?` and `#throws?`.
+  #
+  module ProcMixin
+
+    #
+    # Execute this procedure and return `true` if the specific given `exception`
+    # is raised, otherwise `false`.
+    #
+    # @return [true,false] Whether exception was raised.
+    #
+    def raises?(exception)
+      begin
+        call
+        false
+      rescue exception => err
+        exception == err.class
+      rescue Exception => err
+        false
+      end
+    end
+
+    #
+    # Execute this procedure and return `true` if the given `exception`,
+    # or subclass there-of is raised, otherwise `false`.
+    #
+    # @return [true,false] Whether exception was rescued.
+    #
+    def rescues?(exception)
+      begin
+        call
+        false
+      rescue exception => err
+        true
+      rescue Exception => err
+        false
+      end
+    end
+
+    #
+    # Execute this procedure and return `true` if the given `object`,
+    # is thrown, otherwise `false`.
+    #
+    # @return [true,false] Whether object was thrown.
+    #
+    def throws?(object)
+      pass = true
+      catch(object) do
+        begin
+          call
+        rescue ArgumentError => err     # 1.9 exception
+          #msg += ", not #{err.message.split(/ /).last}"
+        rescue NameError => err         # 1.8 exception
+          #msg += ", not #{err.name.inspect}"
+        end
+        pass = false
+      end
+      pass
+    end
+
+  end
+
+  # Class-level extension for Exception class that adds `#raised?` and `#rescued?`.
+  #
+  module ExceptionExtension
+
+    #
+    # Yield a given block and return `true` if this exception specifically
+    # is raised, otherwise `false`.
+    #
+    # @return [true,false] Whether exception is raised.
+    #
+    def raised? #:yield:
+      begin
+        yield
+        false
+      rescue self => err
+        self == err.class
+      rescue Exception
+        false
+      end
+    end
+
+    #
+    # Yield a given block and return `true` if this exception, or a sub-class
+    # there-of is raised, otherwise `false`.
+    #
+    # @return [true,false] Whether exception is rescued.
+    #
+    def rescued? #:yield:
+      begin
+        yield
+        false
+      rescue self
+        true
+      rescue Exception
+        false
+      end
+    end
+
+  end
+
+end
+
+class Object
+  include Bang::MethodMissing
+  include Bang::ObjectMixin
+end
+
+class Proc
+  include Bang::ProcMixin
+end
+
+class Numeric
+  include Bang::NumericMixin
+end
+
+class Exception
+  extend Bang::ExceptionExtension
+end
+

data/lib/bang/minitest.rb

@@ -0,0 +1,2 @@
+require 'brass/adapters/minitest'
+require 'bang'

data/lib/bang/testunit.rb

@@ -0,0 +1,2 @@
+require 'brass/adapters/testunit'
+require 'bang'

data/spec/applique/brass.rb

@@ -0,0 +1,2 @@
+require 'brass'
+require 'brass/expect'

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: bang
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: brass
+  requirement: &23786500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23786500
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &23785960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23785960
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: &23785460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23785460
+description: Bang! Bang! provides a dynamic assertions framework utlizing bang methods
+  and built to BRASS standards.
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- COPYING.md
+- HISTORY.md
+- README.md
+files:
+- lib/bang/minitest.rb
+- lib/bang/testunit.rb
+- lib/bang.rb
+- spec/applique/brass.rb
+- COPYING.md
+- HISTORY.md
+- README.md
+homepage: http://rubyworks.github.com/bang
+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: Bang methods for assertions!
+test_files: []