lax 0.2.1 → 0.2.3

data/README.md

@@ -1,30 +1,65 @@
 lax
 ===
-Lax is an insouciant smidgen of a testing framework that tries to be an invisible wrapper around your ideas about how your code should work.
+Lax is an insouciant smidgen of a testing framework that tries hard to be an invisible wrapper around your ideas about how your code works.
 ```ruby
-Lax.assert do
-  let number: 1,
-      string: 'Hi There',
-      regexp: defer{ /the/ } # lazy evaluation
-
-  number + 1 == 2
-  string.downcase =~ regexp
+Lax.scope do
+  let number: 1,             # let defines targets that are appropriately scoped and
+      string: 'Hi There',    # re-instantiated for each assertion block.
+      regexp: lazy{ /the/ }  # <- lazy evaluation
 
   assert do
-    let number: 2
-    number - 1 == 1
+    that number + 1 == 2,          # these assertions can pass or fail independently
+         string.downcase =~ regexp
+
+    that(regexp.hash).satisfies {|obj| obj.is_a? Fixnum} # you can also easily define your own conditions
   end
-end
 
-Lax::Run[ Lax ] #=> pass, pass, pass
+  string { upcase.strip == 'HI THERE' } # you can also make assertions like this
+
+  before { puts "hiii. i am a callback. i will be run once for each assertion block in my scope." }
+
+  scope do
+    before { puts "i will be run after the before callback in my enclosing scope." }
+    before { @this_ivar = 'is visible in assertion blocks' }
+    after  { puts 'after callbacks also are a thing' }
+
+
+    def self.number_is_even # rspec-like 'shared examples' can be defined like this.
+      number { even? }
+    end
+
+    let number:  2,
+        nothing: regexp.match('ffff') # compound target
+        bool:    true
+
+    number_is_even
+
+    assert 'documented tests' do        # docstrings can optionally be attached to assertion groups.
+      that number - 1 == 1,
+           string.upcase == 'HI THERE', # string is still in scope
+           nothing == nil
+    end
+  end
+
+  scope do
+    let lax: self,
+        open_file: fix(read: "data\nof\nimmediate\ninterest ") # fixtures are also a thing
+    assert do
+      that lax.respond_to?(:bool) == false, # bool is out of scope
+           open_file.read.lines.map(&:strip).size == 4
+    end
+  end
+end
 
+Lax::Run[ Lax ] #=> green dots aww yeah
 ```
 how come lax is neat
 --------------------
-* Minimal bullshit legalese.
-* Easy-to-define custom matchers and hooks.
-* Hackable with a tiny code footprint (< 300 SLOC).
-* Does not pollute your toplevel namespace or infect the entire Ruby object hierarchy with its code.
+* Minimal legalese.
+* Easy-to-define custom matchers.
+* Built-in Rake task generator for quick setup.
+* Small & hackable is a design goal (< 150 SLOC with plenty of hooks for your code)
+* Does not work by infecting the entire object system with its code - neighbourly!
 
 how to make it do it
 --------------------
@@ -32,7 +67,7 @@ how to make it do it
   gem install lax
   cd my/project/root
   echo "require 'lax/rake_task'; Lax::RakeTask.new" >> Rakefile
-  # write yr tests in the test directory (default test)
+  # write tests in yr test directory (defaults to 'test')
   rake lax
 ```
 

data/lib/lax.rb

@@ -1,4 +1,138 @@
-Object::Lax = Class.new(Array)
-Lax::SOURCE = File.new(File.expand_path('../lax/source.rb', __FILE__)).read
-Lax.class_eval Lax::SOURCE
+class Lax < Array
+  VERSION = '0.2.3'
+
+  Lazy = Class.new Proc
+  Run  = ->(lax=Lax, fin=->(n){n}) do
+    fin.call lax.select {|l| l.included_modules.include? AssertionGroup}.map(&:new).flatten
+  end
+  Assertion = Struct.new(:pass, :source, :doc, :exception)
+
+  @lings = []
+  extend Enumerable
+  def self.inherited(ling)
+    @lings << ling
+    ling.lings = []
+  end
+
+  class << self
+    attr_accessor :lings, :src, :doc
+
+    def each(&b)
+      yield self
+      lings.each {|c| c.each(&b)}
+    end
+
+    def let(h)
+      h.each do |key, value|
+        val = (Lazy===value) ? value : lazy{value}
+        define_singleton_method(key) do |&b|
+          b ? assert { that val.call.instance_exec(&b) } : val.call
+        end
+        define_method(key) do
+          (@_memo||={}).has_key?(key)? @_memo[key] : @_memo[key] = val.call
+        end
+      end
+    end
+
+    def lazy
+      Lazy.new
+    end
+
+    def fix(hash)
+      Struct.new(*hash.keys).new *hash.values
+    end
+
+    def before(&bef)
+      ->(m) { define_method(:before) do |*a|
+        m.bind(self).call *a
+        instance_exec(*a, &bef)
+      end }.call instance_method :before
+    end
+
+    def assert(doc=nil,&spec)
+      scope do
+        @doc, @src = doc, spec.source_location
+        include AssertionGroup
+        before(&spec)
+      end
+    end
+
+    def scope(&b)
+      Class.new(self, &b)
+    end
+
+    def after(&aft)
+      ->(m) { define_method(:after) do |*a|
+        instance_exec(*a, &aft)
+        m.bind(self).call *a
+      end }.call instance_method :after
+    end
+
+    def matcher(sym,&p)
+      define_method(sym) { satisfies &p}
+    end
+  end
+
+  def before(*a); end
+  def after(*a);  end
+
+  module AssertionGroup
+    def fix(hash)
+      self.class.fix hash
+    end
+
+    def that(*as)
+      concat as.map {|a| assert a}
+    end
+
+    def satisfies
+      push assert yield pop
+    end
+
+    def assert(v,x=nil)
+      Assertion.new !!v, self.class.src, self.class.doc, x
+    end
+
+    def initialize
+      before
+    rescue => e
+      push assert(false, e)
+    ensure
+      after self
+    end
+  end
+
+  module RakeTask
+    def self.new(opts = {})
+      require 'rake'
+      extend Rake::DSL
+      o = {dir: :test, name: :lax}.merge(opts)
+      namespace o[:name] do
+        task(:load) { Dir["./#{o[:dir]}/**/*.rb"].each {|f| load f} }
+        task(:run) do
+          Lax.after &Output::DOTS
+          Run[ Lax, ->(n){Output::FAILURES[n]; Output::SUMMARY[n]} ]
+        end
+      end
+      task o[:name] => ["#{o[:name]}:load", "#{o[:name]}:run"]
+    end
+  end
+
+  module Output
+    DOTS = ->(tc) {
+      tc.each {|c| print c.pass ? "\x1b[32m.\x1b[0m" : "\x1b[31mX\x1b[0m"}
+    }
+
+    SUMMARY = ->(cs) {
+      puts "pass: #{cs.select(&:pass).size}\nfail: #{cs.reject(&:pass).size}"
+    }
+    FAILURES = ->(cs) {
+      puts
+      cs.reject(&:pass).each do |f|
+        puts "  failure in #{f.doc || 'an undocumended node'} at #{f.source*?:}"
+        puts "    raised #{f.exception.class} : #{f.exception.message}" if f.exception
+      end
+    }
+  end
+end
 

data/spec/acceptance/acceptance_spec.rb

@@ -2,25 +2,42 @@ require 'spec_helper'
 
 describe Lax do
 
-  let :simple_case do
-    Lax.assert do
-      let number: 19,
-          string: 'asdf',
-          symbol: :symbol
+  context 'a simple case' do
+    let :simple_case do
+      Lax.scope do
+        let number: 19,
+            string: 'asdf',
+            symbol: :symbol
 
-      number.odd? == true
-      number == 19
-      string == 'asdf'
-      number == 20
-      string.upcase == 'ASDF'
-      symbol.to_s == 'symbol'
+        assert do
+          that number.odd? == true,
+            number == 19,
+            string == 'asdf',
+            number == 20,
+            string.upcase == 'ASDF',
+            symbol.to_s == 'symbol'
+        end
+      end
     end
+
+    subject { simple_case.lings.last.new }
+    it      { should have(6).things }
+    specify { subject.select(&:pass).should have(5).things }
+    specify { subject.reject(&:pass).should have(1).things }
   end
 
-  subject { simple_case.new }
-  it      { should have(6).things }
-  specify { subject.select(&:pass?).should have(5).things }
-  specify { subject.reject(&:pass?).should have(1).things }
+  context 'compound targets' do
+    let :comp do
+      Lax.scope do
+        let number: 21
+        let thirty: number + 9
+        assert { that thirty == 30 }
+      end
+    end
+    subject { comp.lings.last.new }
+    it { should have(1).thing }
+    specify { subject.first.pass.should == true }
+  end
 
 end
 

data/spec/spec_helper.rb

@@ -6,5 +6,4 @@ RSpec.configure do |config|
   config.color_enabled = true
 end
 
-Lax.config.run.hooks.after = Lax::Hook.noop # suppress output
 

data/spec/unit/lax_spec.rb

@@ -1,20 +1,38 @@
 require 'spec_helper'
 
 describe Lax do
-  subject { Lax }
+  let(:lax) { Class.new(Lax) }
 
   describe '::let' do
-    before do
-      Lax.let number: 1
-      Lax.number == 1
-    end
-    subject { Lax.instance_methods - Lax.superclass.instance_methods }
-    it { should have(1).thing }
+    before { lax.let number: 1 }
+    specify { lax.methods.should include :number }
+    specify { lax.instance_methods.should include :number }
+    specify { lax.number.should == 1 }
+    specify { lax.new.number.should == 1 }
   end
 
   describe '#initialize' do
-    subject { Lax.reboot.new }
+    subject { lax.new }
     it { should be_empty }
   end
+
+  describe '::scope' do
+    subject { Lax.scope }
+    specify { Lax.lings.should include subject }
+    its(:superclass) { should == Lax  }
+    its(:new) { should be_empty       }
+  end
+
+  describe '::assert' do
+    subject do
+      Lax.scope do
+        let number: 22
+        assert('hahawow') { that number == 22 }
+      end.lings.last
+    end
+    specify   { subject.superclass.superclass.should be Lax }
+    its(:doc) { should == 'hahawow'  }
+    its(:new) { should have(1).thing }
+  end
 end
 

data/test/control.rb

@@ -1,28 +1,77 @@
-Lax.assert do
+Lax.scope do
   let number: 1,
-    string: 'asdf',
-    symbol: :a_sym,
-    regexp: _{/asd/}
+      string: 'asdf',
+      symbol: :a_sym,
+      regexp: lazy{/asd/}
 
-  assert do
-    number == 1
-    assert do
+  scope do
+    assert { that number == 1 }
+    scope do
       let number: 2
-      number == 2
-
-      string.upcase.downcase == 'asdf'
-      string =~ regexp
+      assert do
+        that number == 2,
+             number.even?,
+             string.upcase.downcase == 'asdf',
+             string =~ regexp
+      end
     end
   end
 end
-Lax.assert do
+
+Lax.scope do
   let number: 1,
-    string: 'Hi There',
-    regexp: defer{ /the/ }
-  number + 1 == 2
-  string.downcase =~ regexp
+      string: 'Hi There',
+      regexp: lazy{ /the/ } # lazy evaluation
+
+  string {upcase == 'HI THERE'}
+
   assert do
-    let number: 2
-    number - 1 == 1
+    that number + 1 == 2,
+      string.downcase =~ regexp
+  end
+
+#  before { puts "i will be run once for each assert block in my scope" }
+#  after  { puts "are stackable" }
+
+  scope do
+
+    def self.number_is_even
+      number { even? }
+    end
+
+    let number: 2,
+        nothing: regexp.match('ffff'),
+        bool:    true
+    before { @qqq=9}
+
+    number_is_even
+
+    assert 'documented tests' do
+      that number + @qqq == 11,
+        number - 1 == 1,
+        string.upcase == 'HI THERE', # string is in scope
+        nothing == nil
+   end
+  end
+
+  scope do
+    let lax: self,
+        open_file: fix(read: "data\nof\nimmediate\ninterest ") # fixtures
+   assert do
+     that lax.respond_to?(:bool) == false # bool is out of scope
+     that open_file.read.lines.map(&:strip).size == 4
+    end
   end
 end
+
+Lax.scope do
+  let lax: Lax
+  assert do
+    group = lax.scope do
+      let altitude: 10000
+      assert { that altitude > 1000 }
+    end.lings.first.new
+    that group.size==1
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lax
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-22 00:00:00.000000000 Z
+date: 2012-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -35,17 +35,12 @@ extra_rdoc_files: []
 files:
 - lax.gemspec
 - lib/lax.rb
-- lib/lax/rake_task.rb
-- lib/lax/source.rb
 - README.md
 - LICENSE
 - test/control.rb
 - spec/spec_helper.rb
 - spec/acceptance/acceptance_spec.rb
-- spec/unit/hook_spec.rb
-- spec/unit/target_spec.rb
 - spec/unit/lax_spec.rb
-- spec/unit/fixture/hashable_spec.rb
 homepage: http://github.com/gwentacle/lax
 licenses:
 - MIT/X11
@@ -75,7 +70,4 @@ test_files:
 - test/control.rb
 - spec/spec_helper.rb
 - spec/acceptance/acceptance_spec.rb
-- spec/unit/hook_spec.rb
-- spec/unit/target_spec.rb
 - spec/unit/lax_spec.rb
-- spec/unit/fixture/hashable_spec.rb

data/lib/lax/rake_task.rb

@@ -1,20 +0,0 @@
-require 'rake'
-require 'lax'
-class Lax
-  module RakeTask
-    class << self
-      include Rake::DSL
-      def new(opts = {})
-        o = Lax.config.task.merge opts
-        namespace o[:name] do
-          task(:load) { Dir["./#{o[:dir]}/**/*.rb"].each {|f| load f} }
-          task(:run) do
-            Lax::Run[ Lax ]
-          end
-        end
-        task o[:name] => ["#{o[:name]}:load", "#{o[:name]}:run"]
-      end
-    end
-  end
-end
-

data/lib/lax/source.rb

@@ -1,288 +0,0 @@
-VERSION = '0.2.1'
-
-class Assertion < Struct.new :name, :subject, :condition, :src, :matcher, :args, :hooks
-  def pass?
-    memoize(:pass) { condition.call value }
-  end
-
-  def value
-    memoize(:value) { subject.call }
-  end
-
-  def validate
-    memoize(:validate) do
-      hooks.before.call self
-      pass?
-      self.tap { hooks.after.call self }
-    end
-  end
-
-  private
-  def memoize(key)
-    @memo ||= {}
-    @memo.has_key?(key) ? @memo[key] : @memo[key] = yield
-  end
-
-  class Xptn < Struct.new :assertion, :exception
-    attr_accessor :name, :src, :matcher, :args
-
-    def pass?
-      false
-    end
-
-    def value
-      nil
-    end
-
-    def initialize(a, x)
-      super
-      %w{name src matcher args}.each {|m| send "#{m}=", a.send(m)}
-    end
-  end
-end
-
-module Fixture
-  def self.new(hash)
-    klass = Struct.new(*hash.keys)
-    klass.send :include, self
-    klass.new *hash.values
-  end
-
-  module Hashable
-    def self.new(hashable)
-      hash = hashable.to_hash
-      klass = Struct.new(*hash.keys)
-      klass.send :include, self, Fixture
-      klass.new(*hash.values.map do |val|
-        (Hash===val) ? new(val) : val
-      end)
-    end
-
-    def to_hash
-      Hash[
-        members.zip entries.map {|e| e.kind_of?(Hashable) ? e.to_hash : e }
-      ]
-    end
-
-    def merge(hashable)
-      Hashable.new to_hash.merge hashable
-    end
-  end
-end
-
-class Target < BasicObject
-  def self.define_matcher(sym, &p)
-    define_method(sym) do |*a,&b|
-      p ? 
-        satisfies(sym) do |o|
-          p[*a.map {|v| resolve v},&b][o]
-        end :
-        satisfies(sym,*a) do |o|
-          o.__send__ sym,*a.map {|v| resolve v},&b
-        end
-    end
-  end
-
-  def self.define_predicate(sym)
-    if sym =~ /(.*)(\?|_?p)$/
-      define_method($1) { satisfies($1) {|o| o.__send__ sym} }
-    else
-      raise ArgumentError, "#{sym} does not appear to be a predicate"
-    end
-  end
-
-  %w{== === != =~ !~ < > <= >=}.each {|m| define_matcher m}
-  %w{odd? even? is_a? kind_of? include?}.each {|m| define_predicate m}
-
-  def initialize(node, subj, name, src)
-    @node, @subj, @name, @src = node, subj, name, src 
-  end
-
-  def satisfies(matcher=nil, *args, &cond)
-    assert!(cond, *[ matcher, args ])
-  end
-
-  def method_missing(sym, *args, &blk)
-    Target.new @node, ->{@subj.call.__send__(sym, *args, &blk)}, @name, @src
-  end
-
-  def __val__
-    @subj.call
-  end
-
-  private
-  def assert!(cond, matcher=nil, args=nil)
-    name, subj, src, hooks = @name, @subj, @src, @node.hooks
-    ord = @node.instance_methods.size.to_s
-    @node.send(:include, ::Module.new do
-      define_method(ord) do
-        ::Lax::Assertion.new name, subj, cond, src, matcher, args, hooks
-      end
-    end)
-  end
-
-  def resolve(v)
-    ::Lax::Target === v ? v.__val__ : v
-  end
-
-end
-
-module Run
-  def self.[](lax)
-    hook = lax.config.run.hooks
-    hook.start[ as = lax.map(&:new).flatten ]
-    as.map do |assertion|
-      hook.before[ assertion ]
-      validate_protect(assertion).tap {|v| hook.after[v]}
-    end.tap {|vs| hook.finish[vs]}
-  end
-
-  private
-  def self.validate_protect(a)
-    begin
-      a.validate
-    rescue => e
-      Assertion::Xptn.new(a, e)
-    end
-  end
-end
-
-class Hook < Proc
-  class << self
-    def _resolve(hook)
-      if hook.is_a? Hook
-        hook
-      elsif hook.is_a? Proc
-        new &hook
-      elsif hook.is_a?(Symbol) and self.respond_to?(hook)
-        send hook
-      else
-        raise NameError, "Unable to resolve hook `#{hook}'"
-      end
-    end
-
-    def noop
-      new {|*a|}
-    end
-
-    def output
-      new {|tc| print tc.pass? ? "\x1b[32m.\x1b[0m" : "\x1b[31mX\x1b[0m"}
-    end
-
-    # Returns a hook for generating terminal output from test cases.
-    def summary
-      new {|cs| puts "\nFinished #{cs.size} tests with #{cs.reject(&:pass?).size} failures"}
-    end
-
-    # Returns a hook for generating terminal output from test cases.
-    def failures
-      new do |cs|
-        cs.reject(&:pass?).each do |f|
-          puts "  #{f.src}\n    " <<
-            "#{f.exception ?
-              "(raised an unhandled #{f.exception.class})" :
-              "(got #{f.subject})"}"
-        end
-      end
-    end
-
-    def define(sym, &p)
-      define_singleton_method(sym) {new &p}
-    end
-  end
-
-  def <<(hook)
-    Hook.new {|*a,&b| call(Hook._resolve(hook)[*a,&b])}
-  end
-
-  def +(hook)
-    Hook.new {|*a,&b| call(*a,&b); Hook._resolve(hook)[*a,&b]}
-  end
-end
-
-CONFIG = Fixture::Hashable.new(
-  task: { dir: :test, name: :lax },
-  node: {
-    hooks: {
-      before: Hook.noop,
-      after:  Hook.noop
-    }
-  },
-  run: {
-    hooks: { 
-      start:  Hook.noop,
-      before: Hook.noop,
-      after:  Hook.output,
-      finish: Hook.summary
-    }
-  }
-)
-
-@hooks    = CONFIG.node.hooks
-@children = []
-
-def self.inherited(child)
-  @children << child
-  child.hooks    = @hooks.dup
-  child.children = []
-end
-
-extend Enumerable
-
-class << self
-  attr_accessor :hooks, :children
-
-  def reboot(suppress_warning = true)
-    (stderr, $stderr = $stderr, StringIO.new) if suppress_warning
-    Object.const_set :Lax, Class.new(Array)
-    Lax.const_set :SOURCE, SOURCE
-    Lax.class_eval SOURCE
-    ($stderr = stderr) if suppress_warning
-    Lax
-  end
-
-  def config
-    block_given? ? yield(CONFIG) : CONFIG
-  end
-
-  def matcher(sym, &b)
-    Target.define_matcher(sym, &b)
-  end
-
-  def hook(sym, &b)
-    Hook.define(sym, &b)
-  end
-
-  def each(&b)
-    yield self
-    children.each {|c| c.each(&b)}
-  end
-
-  def let(h)
-    h.each do |key, value|
-      val = value.is_a?(Hook) ? value : ->{value}
-      define_singleton_method(key) do
-        Target.new(self, val, key, caller[0])
-      end
-    end
-  end
-
-  def defer(&v)
-    Hook.new(&v)
-  end
-  alias _ defer
-
-  def fix(hash)
-    Fixture.new(hash)
-  end
-
-  def assert(*vals, &b)
-    Class.new(self).tap {|node| node.class_eval(&b)}
-  end
-end
-
-def initialize
-  ks = methods - self.class.superclass.instance_methods
-  ks.map {|k| send k}.each {|k| self << k}
-end
-

data/spec/unit/fixture/hashable_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Lax::Fixture::Hashable do
-  let(:hash) { { name: 'phyllis', fears: { mild: ['spiders'], severe: ['manatees'] } } }
-  let(:config) { Lax::Fixture::Hashable.new hash }
-
-  describe '::new' do
-    specify { ->{Lax::Fixture::Hashable.new}.should raise_error ArgumentError }
-    specify { [:name, :fears].each {|msg| config.should respond_to msg } }
-    specify { config.name.should == 'phyllis' }
-    specify { config.fears.should be_a_kind_of Lax::Fixture::Hashable }
-  end
-
-  describe '#merge' do
-    subject { config.merge manners: 'impeccable' }
-    it { should be_a_kind_of Lax::Fixture::Hashable }
-    specify { subject.name.should == 'phyllis' }
-    specify { subject.manners.should == 'impeccable' }
-    specify { subject.fears.should be_a_kind_of Lax::Fixture::Hashable }
-  end
-
-  describe '#to_hash' do
-    subject { config.to_hash }
-    it { should == hash }
-  end
-end
-

data/spec/unit/hook_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Lax::Hook do
-  let(:one) { Lax::Hook.new {1} }
-  specify { one.should be_a_kind_of Proc }
-
-  describe '#<<' do
-    let(:doubler) { Lax::Hook.new {|n| 2*n} }
-    subject { doubler << one }
-    its(:call) { should == 2 }
-  end
-
-  describe '#+' do
-    let(:thing) { Object.new }
-    let(:hash)  { Lax::Hook.new { thing.hash } }
-    subject { hash + one }
-    its(:call) { should == 1 }
-    specify do
-      thing.should_receive :hash
-      subject.call
-    end
-  end
-
-  describe '::_resolve' do
-    let(:resolve) { Lax::Hook.method :_resolve }
-    context 'given a hook' do
-      let(:hook) { Lax::Hook.new {:surprise!} }
-      subject { resolve[hook] }
-      it { should == hook }
-    end
-
-    context 'given a symbol' do
-      let(:a_hook) { :noop }
-      let(:random_sym) { :asdfqwer }
-      specify { resolve[a_hook].call.should == nil }
-      specify { -> {resolve[random_sym]}.should raise_error NameError }
-    end
-  end
-end
-

data/spec/unit/target_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Lax::Target do
-  let(:node) { Lax.assert { let num: 1 } }
-
-  describe 'establishing a target' do
-    subject { node.num }
-    specify { (Lax::Target === subject).should == true }
-    specify { subject.__val__.should == 1 }
-  end
-
-  context 'when specifying a condition' do
-    before  { node.num == 1234 }
-    specify { node.new.should have(1).thing }
-    describe 'the entailed assertion' do
-      subject { node.new.first }
-      it { should be_an_instance_of Lax::Assertion  }
-      its(:subject) { should be_an_instance_of Proc }
-      its(:name)    { should == :num  }
-      its(:matcher) { should == '=='  }
-      its(:pass?)   { should == false }
-    end
-  end
-end
-