lax 0.0.3 → 0.2.1

data/README.md

@@ -1,43 +1,42 @@
 lax
 ===
-An insouciant smidgen of a testing framework that is not the boss of you.
+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.
 ```ruby
-  Lax.test {
-    calling(:/).on(1).with(0).raises ZeroDivisionError
+Lax.assert do
+  let number: 1,
+      string: 'Hi There',
+      regexp: defer{ /the/ } # lazy evaluation
 
-    returns(1) {
-      calling(:+).on(0).with 1
+  number + 1 == 2
+  string.downcase =~ regexp
 
-      on(1) {
-        calling(:+).with 0
-        calling(:*).with 1
+  assert do
+    let number: 2
+    number - 1 == 1
+  end
+end
+
+Lax::Run[ Lax ] #=> pass, pass, pass
 
-        0.upto(10) { |n|
-          calling(:**).with n
-        }
-      }
-    }
-  }
-  Lax.test!
 ```
-yes but why
------------
-* Everything about a test is independently scopeable - methods, arguments, receivers, blocks, expectations, hooks, and any metadata you might care to attach. Testing that one method call satisfies three conditions is as natural as testing that one condition is satisfied by three different method calls. Write tests in whatever way makes sense.
-* No hardcoded constraints on terminal output, handling of failed tests, w/e - it's all done with user-configurable hooks.
-* Code footprint so small, it's hardly there at all (< 200 SLOC).
+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.
 
-make it do it
--------------
+how to make it do it
+--------------------
 ```shell
+  gem install lax
   cd my/project/root
-  mkdir -p lax/test
-  echo "Lax.test {|that| that.calling(:+).on(1).with(99).returns 100}" > lax/test/test.rb
-  echo "require 'lax'; Lax::RakeTask.new(:dir=>'lax')" >> rakefile
+  echo "require 'lax/rake_task'; Lax::RakeTask.new" >> Rakefile
+  # write yr tests in the test directory (default test)
   rake lax
 ```
 
 license
 -------
-X11. See LICENSE for details.
+MIT/X11. See LICENSE for details.
 

data/lax.gemspec

@@ -1,16 +1,17 @@
 $LOAD_PATH << File.expand_path('../lib', __FILE__)
 require 'rake'
-require 'lax/version'
+require 'lax'
 
 Gem::Specification.new do |spec|
   spec.name        = 'lax'
   spec.version     = Lax::VERSION
   spec.author      = 'feivel jellyfish'
   spec.email       = 'feivel@sdf.org'
-  spec.files       = FileList['lax.gemspec','lib/**/*.rb','README.md','LICENSE']
-  spec.test_files  = FileList['rakefile','test/**/*.rb']
+  spec.files       = FileList['lax.gemspec','lib/**/*','README.md','LICENSE']
+  spec.test_files  = FileList['test/**/*.rb','spec/**/*.rb']
   spec.license     = 'MIT/X11'
   spec.homepage    = 'http://github.com/gwentacle/lax'
   spec.summary     = 'An insouciant smidgen of a testing framework.'
-  spec.description = 'A lightweight testing framework that is not the boss of you.'
+  spec.description = 'A lightweight testing framework.'
+  spec.add_development_dependency 'rspec'
 end

data/lib/lax/rake_task.rb

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

@@ -0,0 +1,288 @@
+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/lib/lax.rb

@@ -1,36 +1,4 @@
-require 'lax/version'
-module Lax
-  autoload :Case,   'lax/case'
-  autoload :Tree,   'lax/tree'
-  autoload :Hook,   'lax/hook'
-  autoload :Task,   'lax/task'
-
-  class << self
-    @@cases = []
-    def test(c={},&b)
-      preproc(b)[t=Tree.new(c)]
-      t.leaves.tap {|cs|@@cases+=cs}
-    end
-
-    def test!(opts={})
-      cases = opts[:cases] || @@cases
-      call opts[:start], cases
-      cases.each do |c|
-        call opts[:before], c
-        c.test
-        call opts[:after], c
-      end
-      call opts[:finish], cases
-      cases
-    end
-
-    def call(p, *as)
-      p[*as] if p
-    end
-
-    def preproc(p)
-      p.parameters.any?? p : ->(o) { o.instance_exec &p }
-    end
-  end
-end
+Object::Lax = Class.new(Array)
+Lax::SOURCE = File.new(File.expand_path('../lax/source.rb', __FILE__)).read
+Lax.class_eval Lax::SOURCE
 

data/spec/acceptance/acceptance_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Lax do
+
+  let :simple_case do
+    Lax.assert do
+      let number: 19,
+          string: 'asdf',
+          symbol: :symbol
+
+      number.odd? == true
+      number == 19
+      string == 'asdf'
+      number == 20
+      string.upcase == 'ASDF'
+      symbol.to_s == 'symbol'
+    end
+  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 }
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'lax'
+require 'pry'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end
+
+Lax.config.run.hooks.after = Lax::Hook.noop # suppress output
+

data/spec/unit/fixture/hashable_spec.rb

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

@@ -0,0 +1,40 @@
+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/lax_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Lax do
+  subject { 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 }
+  end
+
+  describe '#initialize' do
+    subject { Lax.reboot.new }
+    it { should be_empty }
+  end
+end
+

data/spec/unit/target_spec.rb

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

data/test/control.rb

@@ -0,0 +1,28 @@
+Lax.assert do
+  let number: 1,
+    string: 'asdf',
+    symbol: :a_sym,
+    regexp: _{/asd/}
+
+  assert do
+    number == 1
+    assert do
+      let number: 2
+      number == 2
+
+      string.upcase.downcase == 'asdf'
+      string =~ regexp
+    end
+  end
+end
+Lax.assert do
+  let number: 1,
+    string: 'Hi There',
+    regexp: defer{ /the/ }
+  number + 1 == 2
+  string.downcase =~ regexp
+  assert do
+    let number: 2
+    number - 1 == 1
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lax
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,25 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-14 00:00:00.000000000 Z
-dependencies: []
-description: A lightweight testing framework that is not the boss of you.
+date: 2012-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A lightweight testing framework.
 email: feivel@sdf.org
 executables: []
 extensions: []
@@ -19,19 +35,17 @@ extra_rdoc_files: []
 files:
 - lax.gemspec
 - lib/lax.rb
-- lib/lax/version.rb
-- lib/lax/task.rb
-- lib/lax/case.rb
-- lib/lax/tree.rb
-- lib/lax/hook.rb
+- lib/lax/rake_task.rb
+- lib/lax/source.rb
 - README.md
 - LICENSE
-- rakefile
-- test/case/control.rb
-- test/case/cases.rb
-- test/unit/implicit_receiver.rb
-- test/unit/callbacks.rb
-- test/unit/test.rb
+- 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
@@ -58,9 +72,10 @@ signing_key:
 specification_version: 3
 summary: An insouciant smidgen of a testing framework.
 test_files:
-- rakefile
-- test/case/control.rb
-- test/case/cases.rb
-- test/unit/implicit_receiver.rb
-- test/unit/callbacks.rb
-- test/unit/test.rb
+- 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/case.rb

@@ -1,17 +0,0 @@
-module Lax
-  class Case < Hash
-    def test
-      Lax.call self[:before], self
-      self[:pass] = begin
-        self[:cond][self[:value]=self[:obj].__send__(self[:msg],*self[:args],&self[:blk])]
-      rescue self[:xptn] => e
-        true
-      rescue => e
-        self[:xptn] = e
-        false
-      end
-      Lax.call self[:after], self
-    end
-  end
-end
-

data/lib/lax/hook.rb

@@ -1,24 +0,0 @@
-module Lax
-  class Hook < Proc
-    def <<(cb); Hook.new {|e| self[cb[e]]}    end
-    def +(cb);  Hook.new {|e| self[e]; cb[e]} end
-
-    StartTime = Hook.new { @start = Time.now }
-    StopTime  = Hook.new { @stop  = Time.now }
-    PassFail  = Hook.new {|tc| $stdout.write(tc[:pass] ? "\x1b[32m=\x1b[0m" : "\x1b[31m#\x1b[0m")}
-
-    Summary   = Hook.new do |cases|
-      puts "\nFinished #{cases.size} tests" <<
-        " in #{(@stop - @start).round 10} seconds" <<
-        " with #{(cases.reject{|c|c[:pass]}).size} failures"
-    end
-
-    Failures  = Hook.new do |cases|
-      cases.reject {|c|c[:pass]}.each do |f|
-        puts "  #{Module===f[:obj] ? "#{f[:obj]}::" : "#{f[:obj].class}#"}#{f[:msg]}" <<
-          "#{?(+[*f[:args]]*', '+?) if f[:args]} " << (f.has_key?(:value) ? "#=> #{f[:value]}" : "raised unhandled #{f[:xptn].class}")
-      end
-    end
-  end
-end
-

data/lib/lax/task.rb

@@ -1,36 +0,0 @@
-require 'rake'
-module Lax
-  class Task
-    include Rake::DSL
-    def initialize(opts = {})
-      dir = opts.delete(:dir) || :test
-      make_tasks dir, {
-        start:  Hook::StartTime,
-        after:  Hook::PassFail,
-        finish: Hook::StopTime + Hook::Summary + Hook::Failures
-      }.merge(opts)
-    end
-
-    private
-    def make_tasks(dir, opts)
-      namespace dir do
-        desc "[Lax] load all test files"
-        task load: make_groups(dir)
-        desc "[Lax] run all loaded tests"
-        task(:run) { Lax.test! opts }
-      end
-      desc "[Lax] load and run all tests"
-      task dir => ["#{dir}:load","#{dir}:run"]
-    end
-
-    def make_groups(dir)
-      FileList["#{dir}/**/*"].select {|f| File.directory? f}.map do |group|
-        name = group.sub(/^#{dir}\//,'').gsub(/\//,?:)
-        desc "[Lax] load files in #{group}"
-        task(name) { Dir["#{group}/*.rb"].each {|file| load file} }
-        [dir,name]*?:
-      end
-    end
-  end
-end
-

data/lib/lax/tree.rb

@@ -1,60 +0,0 @@
-module Lax
-  class Tree < Array
-    attr_reader :tc
-    def initialize(tc={})
-      @tc = Case.new.merge tc
-    end
-
-    def on(obj,&b)
-      where({obj: obj},&b)
-    end
-
-    def calling(msg,&b)
-      where({msg: msg},&b)
-    end
-
-    def with(*args,&b)
-      where({args: args},&b)
-    end
-
-    def with_block(blk=nil,&b)
-      blk  ? where({blk: blk},&b)   : where(blk: b)
-    end
-
-    def satisfies(cond=nil,&b)
-      cond ? where({cond: cond},&b) : where(cond: Lax.preproc(b))
-    end
-
-    def before(bef=nil,&b)
-      bef ? where({before: bef},&b) : where(before: b)
-    end
-
-    def after(aft=nil,&b)
-      aft ? where({after: aft},&b)  : where(after: b)
-    end
-
-    def raises(xptn=StandardError,&b)
-      where({xptn: xptn},&b)
-    end
-
-    def it
-      calling(:tap).with_block {}
-    end
-
-    def returns(v,&b)
-      satisfies ->(e){e==v}, &b
-    end
-
-    def where(h,&b)
-      t=Tree.new tc.merge h 
-      Lax.preproc(b)[t] if b
-      push(t).last
-    end
-
-    def leaves
-      any?? map(&:leaves).flatten : [tc]
-    end
-
-  end
-end
-

data/lib/lax/version.rb

@@ -1,3 +0,0 @@
-module Lax
-  VERSION = '0.0.3'
-end

data/rakefile

@@ -1,6 +0,0 @@
-$LOAD_PATH << File.expand_path('../lib', __FILE__)
-require 'lax'
-
-Lax::Task.new
-task default: :test
-

data/test/case/cases.rb

@@ -1,5 +0,0 @@
-Lax.test {|assert|
-  assert.on(rand(0..100)).it.satisfies {|n| Fixnum===n}
-  assert.on(->{QWERTY.uiop[]}).calling(:call).raises
-}
-

data/test/case/control.rb

@@ -1,32 +0,0 @@
-Lax.test(obj: 1) {|that|
-  that.calling(:/).with(0).raises ZeroDivisionError
-  that.calling(:**) {|exponentiation|
-    exponentiation.with(1).satisfies {|n|n==1}
-    exponentiation.with(2).satisfies ->(n){n==1}
-  }
-}
-
-Lax.test {
-  calling(:/).on(1).with(0).raises ZeroDivisionError
-  returns(1) {
-    on(0).calling(:+).with 1
-    on(1) {
-      calling(:* ).with 1
-      calling(:**).with 2
-      calling(:+ ).with 0
-    }
-  }
-}
-
-Lax.test(msg: :object_id, cond: ->(v){Fixnum===v}) {
-  on 1
-  on 'asdf'
-  on String
-  on Lax
-  calling(:size).on([1,2,3])
-}
-
-Lax.test(obj: 222) {|that|
-  that.it.returns 222
-}
-

data/test/unit/callbacks.rb

@@ -1,11 +0,0 @@
-@array = []
-
-Lax.test(obj: @array) {|that|
-  that.before {@array << 1}.calling(:size) {|_|
-    _.returns 1
-    _.returns 2
-    _.after {@array.shift}.returns 3
-    _.returns 3
-  }
-}
-

data/test/unit/implicit_receiver.rb

@@ -1,5 +0,0 @@
-Lax.test {
-  on(2) { calling(:+) { with(3) { satisfies {odd?} } } }
-  on(2).calling(:+).with(3).satisfies &:odd?
-}
-

data/test/unit/test.rb

@@ -1,8 +0,0 @@
-Lax.test {|assert|
-  assert.calling(:upcase).on('asdf').returns('ASDF')
-}
-
-Lax.test(obj: 'asdf') {|test_that|
-  test_that.satisfies {|n| n=='ASDF'}.calling(:upcase)
-}
-