fluidity 0.1.0 → 0.1.1

data/.index

@@ -0,0 +1,56 @@
+---
+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/fluidity
+  label: Homepage
+- type: docs
+  uri: http://rubydoc.info/gems/fluidity
+  label: Documentation
+- type: code
+  uri: http://github.com/rubyworks/fluidity
+  label: Source Code
+- type: mail
+  uri: http://groups.google.com/groups/rubyworks-mailinglist
+  label: Mailing List
+repositories:
+- name: upstream
+  scm: git
+  uri: git@github.com:rubyworks/fluidity.git
+categories: []
+paths:
+  load:
+  - lib
+copyrights:
+- holder: Thomas Sawyer
+  year: '2012'
+  license: BSD-2-Clause
+created: '2012-01-18'
+summary: Fluid Validity
+title: Fluidity
+version: 0.1.1
+name: fluidity
+description: ! 'Fluidity is a test assertions framework built on top of the Assay
+  assertions
+
+  meta-framework. It provides an elegant fluid notation for specifying test assertions.'
+date: '2012-12-21'

data/.ruby

@@ -1,51 +1 @@
----
-source:
-- meta
-- .ruby
-authors:
-- name: Thomas Sawyer
-  email: transfire@gmail.com
-copyrights:
-- holder: Thomas Sawyer
-  year: '2012'
-  license: BSD-2-Clause
-replacements: []
-alternatives: []
-requirements:
-- name: assay
-- name: detroit
-  groups:
-  - build
-  development: true
-- name: qed
-  groups:
-  - test
-  development: true
-dependencies: []
-conflicts: []
-repositories:
-- uri: git@github.com:rubyworks/fluidity.git
-  scm: git
-  name: upstream
-resources:
-  home: http://rubyworks.github.com/fluidity
-  docs: http://rubydoc.info/gems/fluidity
-  code: http://github.com/rubyworks/fluidity
-  mail: http://groups.google.com/groups/rubyworks-mailinglist
-extra: {}
-load_path:
-- lib
-revision: 0
-created: '2012-01-18'
-summary: Fluid Validity
-title: Fluidity
-version: 0.1.0
-name: fluidity
-description: ! 'Fluidity is an assertions grammer built on top of the Assay assertions
-  framework.
-
-  It defines a set of methods which provide a fluid notation for specifying
-
-  test assertions.'
-organization: Rubyworks
-date: '2012-01-27'
+ruby 1.9.3p327 (2012-11-10 revision 37606) [x86_64-linux]

data/DEMOS.md

@@ -0,0 +1,197 @@
+= Fluidity
+
+
+== Should
+
+  require 'fluidity/should'
+
+Now we have a fluent notation with which to make assertions.
+
+  true.should.be.true
+  false.should.be.false
+
+  (5 + 5).should.equal 10
+
+  [1,2,3].should.include(2)
+
+We can also use the associated operator (Ruby's built-in query method name).
+
+  false.should.be.false?
+  true.should.be.true?
+
+  (5 + 5).should == 10
+
+Indefinite article `a` and `an` are suppored.
+
+  12.should.be.a.kind_of?(Integer)
+
+As is `not` for negation.
+
+  12.should.not.equal(20)
+
+We should also make sure such assertions can fail.
+
+  IncludeAssay.should.be.raised do
+    [1,2,3].should.include(4)
+  end
+
+  FalseAssay.should.be.raised do
+    true.should.be.false
+  end
+
+  EqualAssay.should.be.raised do
+    (5 + 5).should == 11
+  end
+
+Matcher notation is also supported, if you have any matcher classes
+to use. Assay classes can be converted to matchers, so we can use 
+one of those to try this out. 
+
+  be_sixteen = EqualAssay[16.0]
+
+  16.should be_sixteen
+
+  15.should_not be_sixteen
+
+
+== Must
+
+  require 'fluidity/must'
+
+Now we have a fluent notation with which to make assertions.
+
+  true.must.be.true
+  false.must.be.false
+
+  (5 + 5).must.equal 10
+
+  [1,2,3].must.include(2)
+
+We can also use the associated operator (Ruby's built-in query method name).
+
+  false.must.be.false?
+  true.must.be.true?
+
+  (5 + 5).must == 10
+
+Indefinite article `a` and `an` are suppored.
+
+  12.must.be.a.kind_of?(Integer)
+
+  12.must.be.an.instance_of?(Fixnum)
+
+As is `not` for negation.
+
+  12.must.not.equal(20)
+
+Or `must_not` can also be used.
+
+  12.must_not.equal(20)
+
+We must also make sure such assertions can fail.
+
+  IncludeAssay.must.be.raised do
+    [1,2,3].must.include(4)
+  end
+
+  FalseAssay.must.be.raised do
+    true.must.be.false
+  end
+
+  EqualAssay.must.be.raised do
+    (5 + 5).must == 11
+  end
+
+Matcher notation is also supported, if you have any matcher classes
+to use. Assay classes can be converted to matchers, so we can use 
+one of those to try this out. 
+
+  be_sixteen = EqualAssay[16.0]
+
+  16.must be_sixteen
+
+  15.must_not be_sixteen
+
+
+= Grammer
+
+  require 'fluidity/assert'
+
+Now we have a fluent notation with which to make assertions.
+
+  true.assert.true
+  false.assert.false
+
+  (5 + 5).must.equal 10
+
+  [1,2,3].must.include(2)
+
+We can also use the associated operator (Ruby's built-in query method name).
+
+  false.assert.false?
+  true.assert.true?
+
+  (5 + 5).assert == 10
+
+  (9 + 9).assert.not == 10
+
+  12.assert.kind_of?(Integer)
+
+As is `not` for negation.
+
+  12.assert.not.equal(20)
+
+Or `should_not` can also be used.
+
+  12.should_not.equal(20)
+
+We must also make sure such assertions can fail. Since #assert is special
+method to assay classes, we can use it as on these as part of our test
+grmmer. So we use the raw `#assert!` method to handle the test.
+
+  RaiseAssay.assert!(IncludeAssay) do
+    [1,2,3].assert.include(4)
+  end
+
+  RaiseAssay.assert!(FalseAssay) do
+    true.assert.false
+  end
+
+  RaiseAssay.assert!(EqualityAssay) do
+    (5 + 5).assert == 11
+  end
+
+Matcher notation is also supported, if you have any matcher classes
+to use. Assay classes can be converted to matchers, so we can use 
+one of those to try this out. 
+
+  is_sixteen = EqualityAssay[16.0]
+
+  16.assert is_sixteen
+
+
+== Other Stuff
+
+What if there is an assertion made for which no Assay class exists?
+If the target object has a query method defined by the same name,
+that is, one ending in a `?` mark, then that mehtod will be used 
+to test the assertion.
+
+  c = Class.new do
+    def initialize(truth)
+      @truth = truth
+    end
+    def yes?
+      @truth
+    end
+    def no?
+      !@truth
+    end
+  end
+
+  x = c.new(true)
+
+  x.should.be.yes
+
+  x.should_not.be.no
+

data/HISTORY.md

@@ -0,0 +1,22 @@
+# HISTORY
+
+## 0.1.1 / 2012-12-21
+
+Fix bug in #assert nomenclature method, and add support for
+both #shouldnt and #musnt in their respective files.
+
+Changes:
+
+* Fix matcher check in #assert.
+* Add #shouldnt as alias for #should_not.
+* Add #musnt as alias for #must_not.
+
+
+## 0.1.0 / 2012-01-27
+
+This is the initial release of Fluidity.
+
+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,79 @@
+# Fluidity
+
+[Website](http://rubyworks.github.com/fluidity) /
+[Report Issue](http://github.com/rubyworks/fluidity/issues) /
+[Source Code](http://github.com/rubyworks/fluidity)
+( [![Build Status](https://secure.travis-ci.org/rubyworks/fluidity.png)](http://travis-ci.org/rubyworks/fluidity) )
+
+<br/>
+
+Fluidity is an assertions framework that provides a very elegant fluid
+notation for specifying test assertions. 
+
+Fluidity is built on top of the [Assay](http://rubyworks.github.com/assay)
+assertions meta-framework, giving it a solid foundation. Assay defines
+assertions in the same way that Ruby defines exceptions. Assay provides
+a complete set of these assertion classes for all common assertion needs.
+
+
+## Instruction
+
+Developers want to write assertions easily and concisely. To this end Fluidity
+provides a flexible grammar system which can be used by requiring any of the
+prime grammar methods that extend Object. The most common is probably `should`.
+
+    require 'fluidity/should'
+
+    10.should.be.kind_of(Integer)
+
+But if you are accustom to MiniTest's spec methods, you might prefer `must`.
+
+    require 'fluidity/must'
+
+    10.must.be.kind_of(Integer)
+
+Also provided is `assert` for those techy aficionados.
+
+  require 'fluidity/assert'
+
+    10.assert.kind_of(Integer)
+
+So what is so fluid about all this? Well, Fluidity allows the developer quite
+the English like expression. For instance.
+
+    10.should.not.be.an.instance_of?(String)
+
+Pretty neat, though perhaps bit excessive for a real-life use. Generally
+it's good enough to use the shorter and a tad bit faster:
+ 
+    10.shouldnt.be.instance_of?(String)
+
+Speaking of _fast_, so what about speed? Of course, running through multiple
+extra method calls to make an assertion is going to be slower than making just
+a single method call. So, yes, tests might run a bit slower on Fluidity than
+they would with another less readable assertions system. However, method calls
+are pretty dang fast and unlikely to present any significant performance 
+overhead on test runs. At most, tests runs might take a few additional seconds
+for _very_ _large_ test suites.
+
+
+## Installation
+
+To install with RubyGems simply open a console and type:
+
+    gem install fluidity
+
+Site installation with the tarball can be done with Ruby Setup
+(gem install setup). See http://rubyworks.github.com/setup.
+
+
+## Copyrights
+
+Fluidity is copyrighted open source software.
+
+    Copyright (c) 2012 Rubyworks
+
+This program can be modified and distributed in accordance with
+the terms of the [BSD-2-Clause](http://spdx.org/licenses/BSD-2-Clause) license.
+
+See LICENSE.txt file for details.

data/demo/00_intro.md

@@ -0,0 +1,2 @@
+# Fluidity
+

data/demo/01_should.md

@@ -0,0 +1,52 @@
+## Should
+
+    require 'fluidity/should'
+
+Now we have a fluent notation with which to make assertions.
+
+    true.should.be.true
+    false.should.be.false
+
+    (5 + 5).should.equal 10
+
+    [1,2,3].should.include(2)
+
+We can also use the associated operator (Ruby's built-in query method name).
+
+    false.should.be.false?
+    true.should.be.true?
+
+    (5 + 5).should == 10
+
+Indefinite article `a` and `an` are suppored.
+
+    12.should.be.a.kind_of?(Integer)
+
+As is `not` for negation.
+
+    12.should.not.equal(20)
+
+We should also make sure such assertions can fail.
+
+    IncludeAssay.should.be.raised do
+      [1,2,3].should.include(4)
+    end
+
+    FalseAssay.should.be.raised do
+      true.should.be.false
+    end
+
+    EqualAssay.should.be.raised do
+      (5 + 5).should == 11
+    end
+
+Matcher notation is also supported, if you have any matcher classes
+to use. Assay classes can be converted to matchers, so we can use 
+one of those to try this out. 
+
+    be_sixteen = EqualAssay[16.0]
+
+    16.should be_sixteen
+
+    15.should_not be_sixteen
+

data/demo/02_must.md

@@ -0,0 +1,58 @@
+## Must
+
+    require 'fluidity/must'
+
+Now we have a fluent notation with which to make assertions.
+
+    true.must.be.true
+    false.must.be.false
+
+    (5 + 5).must.equal 10
+
+    [1,2,3].must.include(2)
+
+We can also use the associated operator (Ruby's built-in query method name).
+
+    false.must.be.false?
+    true.must.be.true?
+
+    (5 + 5).must == 10
+
+Indefinite article `a` and `an` are suppored.
+
+    12.must.be.a.kind_of?(Integer)
+
+    12.must.be.an.instance_of?(Fixnum)
+
+As is `not` for negation.
+
+    12.must.not.equal(20)
+
+Or `must_not` can also be used.
+
+    12.must_not.equal(20)
+
+We must also make sure such assertions can fail.
+
+    IncludeAssay.must.be.raised do
+      [1,2,3].must.include(4)
+    end
+
+    FalseAssay.must.be.raised do
+      true.must.be.false
+    end
+
+    EqualAssay.must.be.raised do
+      (5 + 5).must == 11
+    end
+
+Matcher notation is also supported, if you have any matcher classes
+to use. Assay classes can be converted to matchers, so we can use 
+one of those to try this out. 
+
+    be_sixteen = EqualAssay[16.0]
+
+    16.must be_sixteen
+
+    15.must_not be_sixteen
+

data/demo/03_assert.md

@@ -0,0 +1,56 @@
+## Grammer
+
+    require 'fluidity/assert'
+
+Now we have a fluent notation with which to make assertions.
+
+    true.assert.true
+    false.assert.false
+
+    (5 + 5).must.equal 10
+
+    [1,2,3].must.include(2)
+
+We can also use the associated operator (Ruby's built-in query method name).
+
+    false.assert.false?
+    true.assert.true?
+
+    (5 + 5).assert == 10
+
+    (9 + 9).assert.not == 10
+
+    12.assert.kind_of?(Integer)
+
+As is `not` for negation.
+
+    12.assert.not.equal(20)
+
+Or `should_not` can also be used.
+
+    12.should_not.equal(20)
+
+We must also make sure such assertions can fail. Since #assert is special
+method to assay classes, we can use it as on these as part of our test
+grmmer. So we use the raw `#assert!` method to handle the test.
+
+    RaiseAssay.assert!(IncludeAssay) do
+      [1,2,3].assert.include(4)
+    end
+
+    RaiseAssay.assert!(FalseAssay) do
+      true.assert.false
+    end
+
+    RaiseAssay.assert!(EqualityAssay) do
+      (5 + 5).assert == 11
+    end
+
+Matcher notation is also supported, if you have any matcher classes
+to use. Assay classes can be converted to matchers, so we can use 
+one of those to try this out. 
+
+    is_sixteen = EqualityAssay[16.0]
+
+    16.assert is_sixteen
+

data/demo/04_other.md

@@ -0,0 +1,25 @@
+## Other Stuff
+
+What if there is an assertion made for which no Assay class exists?
+If the target object has a query method defined by the same name,
+that is, one ending in a `?` mark, then that mehtod will be used 
+to test the assertion.
+
+    c = Class.new do
+      def initialize(truth)
+        @truth = truth
+      end
+      def yes?
+        @truth
+      end
+      def no?
+        !@truth
+      end
+    end
+
+    x = c.new(true)
+
+    x.should.be.yes
+
+    x.should_not.be.no
+

data/lib/fluidity.yml

@@ -1,51 +1,56 @@
 ---
-source:
-- meta
-- .ruby
+type: ruby
+revision: 2013
+sources:
+- var
 authors:
 - name: Thomas Sawyer
   email: transfire@gmail.com
-copyrights:
-- holder: Thomas Sawyer
-  year: '2012'
-  license: BSD-2-Clause
-replacements: []
-alternatives: []
+organizations: []
 requirements:
 - name: assay
-- name: detroit
-  groups:
+- groups:
   - build
   development: true
-- name: qed
-  groups:
+  name: detroit
+- groups:
   - test
   development: true
-dependencies: []
+  name: qed
 conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/fluidity
+  label: Homepage
+- type: docs
+  uri: http://rubydoc.info/gems/fluidity
+  label: Documentation
+- type: code
+  uri: http://github.com/rubyworks/fluidity
+  label: Source Code
+- type: mail
+  uri: http://groups.google.com/groups/rubyworks-mailinglist
+  label: Mailing List
 repositories:
-- uri: git@github.com:rubyworks/fluidity.git
+- name: upstream
   scm: git
-  name: upstream
-resources:
-  home: http://rubyworks.github.com/fluidity
-  docs: http://rubydoc.info/gems/fluidity
-  code: http://github.com/rubyworks/fluidity
-  mail: http://groups.google.com/groups/rubyworks-mailinglist
-extra: {}
-load_path:
-- lib
-revision: 0
+  uri: git@github.com:rubyworks/fluidity.git
+categories: []
+paths:
+  load:
+  - lib
+copyrights:
+- holder: Thomas Sawyer
+  year: '2012'
+  license: BSD-2-Clause
 created: '2012-01-18'
 summary: Fluid Validity
 title: Fluidity
-version: 0.1.0
+version: 0.1.1
 name: fluidity
-description: ! 'Fluidity is an assertions grammer built on top of the Assay assertions
-  framework.
-
-  It defines a set of methods which provide a fluid notation for specifying
+description: ! 'Fluidity is a test assertions framework built on top of the Assay
+  assertions
 
-  test assertions.'
-organization: Rubyworks
-date: '2012-01-27'
+  meta-framework. It provides an elegant fluid notation for specifying test assertions.'
+date: '2012-12-21'

data/lib/fluidity/about.rb

@@ -1,17 +1,17 @@
 module Fluidity
 
-  # Access to metadata.
-  def self.metadata
-    @metadata ||= (
-      require 'yaml'
-      YAML.load(File.new(File.dirname(__FILE__) + '/../fluidity.yml'))
-    )
-  end
-
   # Access to project metadata as constants.
   def self.const_missing(name)
     key = name.to_s.downcase
-    metadata[key] || super(name)
+    index[key] || super(name)
+  end
+
+  # Access to project metadata.
+  def self.index
+    @metadata ||= (
+      require 'yaml'
+      YAML.load_file(File.dirname(__FILE__) + '/../fluidity.yml')
+    )
   end
 
 end

data/lib/fluidity/assert.rb

@@ -6,10 +6,13 @@ class Object
   #
   #  10.assert.kind_of?(Integer)
   #
-  def assert(matcher=nil, *args)
+  def assert(matcher=nil, *args, &blk)
     if matcher
-      return super(matcher, *args) unless matcher.respond_to?(:===) # not good enough!!!
-      matcher =~ self
+      if matcher.respond_to?(:=~) # good enough ?
+        matcher =~ self
+      else
+        super(matcher, *args, &blk)
+      end
     else
       ::Fluidity::Grammer::Assert.new(self)
     end

data/lib/fluidity/must.rb

@@ -28,5 +28,11 @@ class Object #BasicObject
     end
   end
 
+  # Contraction do must not.
+  #
+  #  10.mustnt.be.kind_of?(Integer)
+  #
+  alias_method :mustnt, :must_not
+
 end
 

data/lib/fluidity/should.rb

@@ -26,5 +26,7 @@ class Object #BasicObject
     end
   end
 
+  alias_method :shouldnt, :should_not
+
 end
 

data/lib/fluidity/will.rb

@@ -0,0 +1,36 @@
+require 'fluidity/grammer'
+
+class Object #BasicObject
+
+  # Use `will` nomenclature for assertions.
+  #
+  #  10.will.be.kind_of(Integer)
+  #
+  def will(matcher=nil)
+    if matcher
+      matcher =~ self
+    else
+      ::Fluidity::Grammer::Must.new(self)
+    end
+  end
+
+  # Also, `will_not` nomenclature for assertions.
+  #
+  #  10.will_not.be.kind_of?(Integer)
+  #
+  def must_not(matcher=nil)
+    if matcher
+      matcher !~ self
+    else
+      ::Fluidity::Grammer::Must.new(self, true)
+    end
+  end
+
+  # Contraction of will not.
+  #
+  #  10.wont.be.kind_of?(Integer)
+  #
+  alias_method :wont, :will_not
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluidity
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-28 00:00:00.000000000 Z
+date: 2012-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: assay
-  requirement: &21870300 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *21870300
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: detroit
-  requirement: &21869760 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *21869760
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: qed
-  requirement: &21869260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,32 +53,46 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *21869260
-description: ! 'Fluidity is an assertions grammer built on top of the Assay assertions
-  framework.
-
-  It defines a set of methods which provide a fluid notation for specifying
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Fluidity is a test assertions framework built on top of the Assay
+  assertions
 
-  test assertions.'
+  meta-framework. It provides an elegant fluid notation for specifying test assertions.'
 email:
 - transfire@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- LICENSE.txt
+- HISTORY.md
+- README.md
+- DEMOS.md
 files:
+- .index
 - .ruby
+- demo/00_intro.md
+- demo/01_should.md
+- demo/02_must.md
+- demo/03_assert.md
+- demo/04_other.md
 - lib/fluidity/about.rb
 - lib/fluidity/assert.rb
 - lib/fluidity/grammer.rb
 - lib/fluidity/is.rb
 - lib/fluidity/must.rb
 - lib/fluidity/should.rb
+- lib/fluidity/will.rb
 - lib/fluidity.rb
 - lib/fluidity.yml
-- spec/01_should.rdoc
-- spec/02_must.rdoc
-- spec/03_assert.rdoc
-- spec/04_other.rdoc
+- LICENSE.txt
+- HISTORY.md
+- README.md
+- DEMOS.md
 homepage: http://rubyworks.github.com/fluidity
 licenses:
 - BSD-2-Clause
@@ -90,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Fluid Validity

data/spec/01_should.rdoc

@@ -1,52 +0,0 @@
-== Should
-
-  require 'fluidity/should'
-
-Now we have a fluent notation with which to make assertions.
-
-  true.should.be.true
-  false.should.be.false
-
-  (5 + 5).should.equal 10
-
-  [1,2,3].should.include(2)
-
-We can also use the associated operator (Ruby's built-in query method name).
-
-  false.should.be.false?
-  true.should.be.true?
-
-  (5 + 5).should == 10
-
-Indefinite article `a` and `an` are suppored.
-
-  12.should.be.a.kind_of?(Integer)
-
-As is `not` for negation.
-
-  12.should.not.equal(20)
-
-We should also make sure such assertions can fail.
-
-  IncludeAssay.should.be.raised do
-    [1,2,3].should.include(4)
-  end
-
-  FalseAssay.should.be.raised do
-    true.should.be.false
-  end
-
-  EqualAssay.should.be.raised do
-    (5 + 5).should == 11
-  end
-
-Matcher notation is also supported, if you have any matcher classes
-to use. Assay classes can be converted to matchers, so we can use 
-one of those to try this out. 
-
-  be_sixteen = EqualAssay[16.0]
-
-  16.should be_sixteen
-
-  15.should_not be_sixteen
-

data/spec/02_must.rdoc

@@ -1,58 +0,0 @@
-== Must
-
-  require 'fluidity/must'
-
-Now we have a fluent notation with which to make assertions.
-
-  true.must.be.true
-  false.must.be.false
-
-  (5 + 5).must.equal 10
-
-  [1,2,3].must.include(2)
-
-We can also use the associated operator (Ruby's built-in query method name).
-
-  false.must.be.false?
-  true.must.be.true?
-
-  (5 + 5).must == 10
-
-Indefinite article `a` and `an` are suppored.
-
-  12.must.be.a.kind_of?(Integer)
-
-  12.must.be.an.instance_of?(Fixnum)
-
-As is `not` for negation.
-
-  12.must.not.equal(20)
-
-Or `must_not` can also be used.
-
-  12.must_not.equal(20)
-
-We must also make sure such assertions can fail.
-
-  IncludeAssay.must.be.raised do
-    [1,2,3].must.include(4)
-  end
-
-  FalseAssay.must.be.raised do
-    true.must.be.false
-  end
-
-  EqualAssay.must.be.raised do
-    (5 + 5).must == 11
-  end
-
-Matcher notation is also supported, if you have any matcher classes
-to use. Assay classes can be converted to matchers, so we can use 
-one of those to try this out. 
-
-  be_sixteen = EqualAssay[16.0]
-
-  16.must be_sixteen
-
-  15.must_not be_sixteen
-

data/spec/03_assert.rdoc

@@ -1,56 +0,0 @@
-= Grammer
-
-  require 'fluidity/assert'
-
-Now we have a fluent notation with which to make assertions.
-
-  true.assert.true
-  false.assert.false
-
-  (5 + 5).must.equal 10
-
-  [1,2,3].must.include(2)
-
-We can also use the associated operator (Ruby's built-in query method name).
-
-  false.assert.false?
-  true.assert.true?
-
-  (5 + 5).assert == 10
-
-  (9 + 9).assert.not == 10
-
-  12.assert.kind_of?(Integer)
-
-As is `not` for negation.
-
-  12.assert.not.equal(20)
-
-Or `should_not` can also be used.
-
-  12.should_not.equal(20)
-
-We must also make sure such assertions can fail. Since #assert is special
-method to assay classes, we can use it as on these as part of our test
-grmmer. So we use the raw `#assert!` method to handle the test.
-
-  RaiseAssay.assert!(IncludeAssay) do
-    [1,2,3].assert.include(4)
-  end
-
-  RaiseAssay.assert!(FalseAssay) do
-    true.assert.false
-  end
-
-  RaiseAssay.assert!(EqualityAssay) do
-    (5 + 5).assert == 11
-  end
-
-Matcher notation is also supported, if you have any matcher classes
-to use. Assay classes can be converted to matchers, so we can use 
-one of those to try this out. 
-
-  is_sixteen = EqualityAssay[16.0]
-
-  16.assert is_sixteen
-

data/spec/04_other.rdoc

@@ -1,24 +0,0 @@
-== Other Stuff
-
-What if there is an assertion made for which no Assay class exists?
-If the target object has a query method defined by the same name,
-that is, one ending in a `?` mark, then that mehtod will be used 
-to test the assertion.
-
-  c = Class.new do
-    def initialize(truth)
-      @truth = truth
-    end
-    def yes?
-      @truth
-    end
-    def no?
-      !@truth
-    end
-  end
-
-  x = c.new(true)
-
-  x.should.be.yes
-
-  x.should_not.be.no