fluidity 0.1.0

data/.ruby

@@ -0,0 +1,51 @@
+---
+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'

data/lib/fluidity.rb

@@ -0,0 +1,6 @@
+require 'fluidity/about'
+require 'fluidity/grammer'
+require 'fluidity/should'
+require 'fluidity/must'
+require 'fluidity/assert'
+

data/lib/fluidity.yml

@@ -0,0 +1,51 @@
+---
+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'

data/lib/fluidity/about.rb

@@ -0,0 +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)
+  end
+
+end

data/lib/fluidity/assert.rb

@@ -0,0 +1,24 @@
+require 'fluidity/grammer'
+
+class Object
+
+  # Use `assert` nomenclature for assertions.
+  #
+  #  10.assert.kind_of?(Integer)
+  #
+  def assert(matcher=nil, *args)
+    if matcher
+      return super(matcher, *args) unless matcher.respond_to?(:===) # not good enough!!!
+      matcher =~ self
+    else
+      ::Fluidity::Grammer::Assert.new(self)
+    end
+  end
+
+end
+
+
+module Kernel
+  public :assert
+  public :refute
+end

data/lib/fluidity/grammer.rb

@@ -0,0 +1,121 @@
+require 'assay'
+
+module Fluidity
+
+  module Grammer
+
+    class Base
+
+      def initialize(target, negate=false)
+        @target = target
+        @negate = negate
+      end
+
+      # Have to override the ususal `#==` method to support this.
+      def ==(other)
+        if @negate
+          ::EqualAssay.refute!(@target, other, :backtrace=>caller)
+        else
+          ::EqualAssay.assert!(@target, other, :backtrace=>caller)
+        end
+      end
+
+    #private
+
+      def method_missing(s, *a, &b)
+        if assay = (::Assertion.by_name(s) || ::Assertion.by_operator(s))
+          if @negate
+            assay.refute!(@target, *a, &b)
+          else
+            assay.assert!(@target, *a, &b)
+          end
+        else
+          q = (s.to_s.end_with?('?') ? s : (s.to_s+'?'))
+          if @target.respond_to?(q)
+            assert(false, "#{q} failed", caller) unless @target.send(q, *a, &b)
+          else
+            super(s, *a, &b)
+          end
+        end
+      end
+
+    end
+
+    #
+    class Assert < Base
+
+      #def method_missing(s, *a, &b)
+      #  call(s, *a, &b)
+      #end
+
+      def not
+        Assert.new(@target, !@negate)
+      end
+
+    end
+
+    #
+    class Be < Base
+
+      #def method_missing(s, *a, &b)
+      #  call(s, *a, &b)
+      #end
+
+      #
+      def a
+        self
+      end
+
+      #
+      def an
+        self
+      end
+
+    end
+
+    #
+    class Is < Be
+
+      def not
+        Is.new(@target, !@negate)
+      end
+
+    end
+
+    #
+    class Must < Base
+
+      #def method_missing(s, *a, &b)
+      #  call(s, *a, &b)
+      #end
+
+      def be
+        Be.new(@target, @negate)
+      end
+
+      def not
+        Must.new(@target, !@negate)
+      end
+
+    end
+
+    #
+    class Should < Base
+
+      #def method_missing(s, *a, &b)
+      #  call(s, *a, &b)
+      #end
+
+      def be
+        Be.new(@target, @negate)
+      end
+
+      def not
+        Should.new(@target, !@negate)
+      end
+
+    end
+
+  end
+
+end

data/lib/fluidity/is.rb

@@ -0,0 +1,18 @@
+require 'fluidity/grammer'
+
+class Object #BasicObject
+
+  # Use `is` nomenclature for assertions.
+  #
+  #  10.is.kind_of?(Integer)
+  #
+  def is(matcher=nil)
+    if matcher
+      matcher === self
+    else
+      ::Fluidity::Grammer::Is.new(self)
+    end
+  end
+
+end
+

data/lib/fluidity/must.rb

@@ -0,0 +1,32 @@
+require 'fluidity/grammer'
+
+# TODO: What about BasicObject ?
+
+class Object #BasicObject
+
+  # Use `must` nomenclature for assertions.
+  #
+  #  10.must.be.kind_of(Integer)
+  #
+  def must(matcher=nil)
+    if matcher
+      matcher =~ self
+    else
+      ::Fluidity::Grammer::Must.new(self)
+    end
+  end
+
+  # Also, `must_not` nomenclature for assertions.
+  #
+  #  10.must_not.be.kind_of?(Integer)
+  #
+  def must_not(matcher=nil)
+    if matcher
+      matcher !~ self
+    else
+      ::Fluidity::Grammer::Must.new(self, true)
+    end
+  end
+
+end
+

data/lib/fluidity/should.rb

@@ -0,0 +1,30 @@
+require 'fluidity/grammer'
+
+class Object #BasicObject
+
+  # Use `should` nomenclature for assertions.
+  #
+  #  10.should.be.kind_of(Integer)
+  #
+  def should(matcher=nil)
+    if matcher
+      matcher =~ self
+    else
+      ::Fluidity::Grammer::Should.new(self)
+    end
+  end
+
+  # Also, `should_not` nomenclature for assertions.
+  #
+  #  10.should_not.be.kind_of?(Integer)
+  #
+  def should_not(matcher=nil)
+    if matcher
+      matcher !~ self
+    else
+      ::Fluidity::Grammer::Should.new(self, true)
+    end
+  end
+
+end
+

data/spec/01_should.rdoc

@@ -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/spec/02_must.rdoc

@@ -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/spec/03_assert.rdoc

@@ -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/spec/04_other.rdoc

@@ -0,0 +1,24 @@
+== 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

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: fluidity
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: assay
+  requirement: &21870300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21870300
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &21869760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21869760
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: &21869260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        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
+
+  test assertions.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .ruby
+- 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.rb
+- lib/fluidity.yml
+- spec/01_should.rdoc
+- spec/02_must.rdoc
+- spec/03_assert.rdoc
+- spec/04_other.rdoc
+homepage: http://rubyworks.github.com/fluidity
+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.10
+signing_key: 
+specification_version: 3
+summary: Fluid Validity
+test_files: []