must 0.2.8 → 0.2.9

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.ruby-version

data/Rakefile

@@ -1,24 +1 @@
 require "bundler/gem_tasks"
-
-require 'rake'
-require 'rake/testtask'
-require 'rdoc/task'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the must plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the must plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Must'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/lib/must/differ.rb

@@ -0,0 +1,72 @@
+module Must
+  class Differ
+    attr_reader :a, :b, :path
+
+    def initialize(a, b, path)
+      @a, @b, @path = a, b, path
+    end
+
+    def eq_float?(a, b)
+      (a - b).abs <= 0.0000001
+    end
+
+    def eq_object?(a, b)
+      a == b
+    end
+
+    def execute!
+      unless a.class == b.class
+        failed ClassMismatch, "%s expected [%s], but got [%s]" % [path, a.class, b.class]
+      end
+
+      if a.is_a?(Array)
+        max = [a.size, b.size].max
+        max.times do |i|
+          Differ.new(a[i], b[i], "#{path}[#{i}]").execute!
+        end
+        return true
+      end
+
+      if a.is_a?(Hash)
+        (a.keys | b.keys).each do |key|
+          Differ.new(a[key], b[key], "#{path}[#{key}]").execute!
+        end
+        return true
+      end
+
+      eq = 
+        case a
+        when Float; eq_float?(a, b)
+        else      ; eq_object?(a, b)
+        end
+
+      unless eq
+        av = a.inspect.split(//)[0..50].join
+        bv = b.inspect.split(//)[0..50].join
+        failed ValueMismatch, "%s expected %s(%s), but got %s(%s)" % [path, av, a.class, bv, a.class]
+      end
+
+      return true
+
+    rescue Must::ClassMismatch => err
+      if a.class == b.class
+        as = Must::StructInfo.new(a).inspect
+        bs = Must::StructInfo.new(b).inspect
+        raise Must::StructMismatch, "%s expected %s, but got %s" % [path, as, bs]
+      else
+        raise
+      end
+    end
+
+    def execute
+      execute!
+      return true
+    rescue Must::Invalid
+      return false
+    end
+
+    def failed(klass, msg)
+      raise klass, msg
+    end
+  end
+end

data/lib/must/rule.rb

@@ -1,5 +1,4 @@
 require 'set'
-require "must/struct_info"
 
 module Must
   class Rule
@@ -40,7 +39,13 @@ module Must
     end
 
     def kind_of(*targets, &block)
-      bool = targets.any?{|klass| is_a?(klass)}
+      if instance?(@object)
+        bool = targets.any?{|klass| is_a?(klass)}
+      else
+        # check ancestors when klass
+        bool = (@object.ancestors & targets).any?
+      end
+      
       block ||= proc {
         target = targets.map{|i| instance?(i) ? i.class.name : i.name}.join('|')
         target = "(#{target})" if targets.size > 1
@@ -105,7 +110,7 @@ module Must
     end
 
     def struct(target, &block)
-      block ||= proc{ raise Invalid, Must::StructInfo::Differ.new(@object, target, "").execute.to_s }
+      block ||= proc{ Must::Differ.new(@object, target, "").execute! }
       valid?(struct?(target), &block)
     end
 

data/lib/must/struct_info.rb

@@ -75,56 +75,6 @@ module Must
       extend self
     end
 
-    class Differ
-      attr_reader :a, :b, :path
-
-      def initialize(a, b, path)
-        @a, @b, @path = a, b, path
-      end
-
-      def execute!
-        sa = StructInfo::new(a).inspect
-        sb = StructInfo::new(b).inspect
-
-        unless sa == sb
-          failed("%s expected %s, but got %s" % [path, sb, sa])
-        end
-
-        if a.class == Array
-          max = [a.size, b.size].max
-          (0...max).each do |i|
-            Differ.new(a[i], b[i], "#{path}[#{i}]").execute!
-          end
-          return true
-        end
-
-        if a.class == Hash
-          (a.keys | b.keys).each do |key|
-            Differ.new(a[key], b[key], "#{path}[#{key}]").execute!
-          end
-          return true
-        end
-
-        unless a == b
-          failed("%s expected %s, but got %s" % [path, a.inspect, b.inspect])
-        end
-
-        return nil
-      end
-
-      def execute
-        execute!
-        return nil
-      rescue => err
-        return err
-      end
-
-      private
-        def failed(msg)
-          raise msg
-        end
-    end
-
     ######################################################################
     ### StructInfo
 

data/lib/must/version.rb

@@ -1,3 +1,3 @@
 module Must
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/lib/must.rb

@@ -3,7 +3,9 @@ require "must/version"
 # Must
 module Must
   class Invalid < StandardError; end
-  class ShouldNotEmpty  < Invalid; end
+  class ClassMismatch  < Invalid; end
+  class StructMismatch < Invalid; end
+  class ValueMismatch  < Invalid; end
 
   def must(*args, &block)
     if args.size > 0
@@ -15,4 +17,7 @@ module Must
 end
 
 require "must/rule"
+require "must/differ"
+require "must/struct_info"
+
 Object.__send__ :include, Must

data/spec/coerced_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Must::Rule, "coerced" do
+  let(:obj) { {"xyz" => ["a","b"] } }
+
+  describe "is_a" do
+    specify "[OK]" do
+      1.must.be.coerced(Integer).should == 1
+      1.must.be.coerced(Integer, String).should == 1
+      1.must.be.coerced(String, Numeric).should == 1
+    end
+
+    specify "[NG]" do
+      lambda { "1".must.be.coerced(Integer) }.should raise_error(Must::Invalid)
+      lambda { "1".must.be.coerced(Integer, Range) }.should raise_error(Must::Invalid)
+      lambda { "1".must.be.coerced(Integer){raise NotImplementedError} }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "coercing" do
+    specify "[OK]" do
+      1.must.be.coerced(Integer, String=>proc{|i|i.to_i}).should == 1
+      "1".must.be.coerced(Integer, String=>proc{|i|i.to_i}).should == 1
+      "1".must.be.coerced(Integer, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first}).should == 1
+      "1".must.be.coerced(Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first}).should == 1
+      "1".must.be.coerced(File, Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first}).should == 1
+    end
+
+    specify "[NG]" do
+      lambda { "1".must.be.coerced(Integer, String=>proc{|i| /a/}) }.should raise_error(Must::Invalid)
+      lambda { "1".must.be.coerced(Integer, String=>proc{|i| /a/}) {raise NotImplementedError}  }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe "cascaded" do
+    specify "[OK]" do
+      1.must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i).should == 1
+      "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i).should == 1
+      :"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i).should == 1
+    end
+
+    specify "[NG] detect livelock" do
+      lambda {"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}.should raise_error(Must::Invalid)
+      lambda {:"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}.should raise_error(Must::Invalid)
+    end
+  end
+end

data/spec/differ_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Must::Differ do
+  let(:a) {}
+  let(:b) {}
+  let(:path) { "obj" }
+
+  subject { lambda { Must::Differ.new(a, b, path).execute! } }
+
+  context "(same class)" do
+    context "(same objects)" do
+      let(:a) { 1 }
+      let(:b) { 1 }
+      it { should_not raise_error }
+    end
+
+    context "(same values)" do
+      let(:a) { [1] }
+      let(:b) { [1] }
+      it { should_not raise_error }
+    end
+
+    context "(different values)" do
+      let(:a) { [1] }
+      let(:b) { [2] }
+      it { should raise_error(Must::ValueMismatch) }
+    end
+
+    context "(different hash)" do
+      let(:a) { {
+          "currency"=>"JPY",
+          "strategy"=>"version_1",
+        } }
+      let(:b) { {
+          "currency"=>"JPY",
+          "strategy"=>"classic",
+        } }
+      it { should raise_error(Must::ValueMismatch) }
+      it { should raise_error(/strategy/) }
+    end
+  end
+
+  context "(same struct)" do
+    context "(same objects)" do
+      let(:x) { [ { "host" => "x" },  { "host" => "y" } ] }
+      let(:a) { x }
+      let(:b) { x }
+      it { should_not raise_error }
+    end
+
+    context "(same values)" do
+      let(:a) { [ { "host" => "x" },  { "host" => "y" } ] }
+      let(:b) { [ { "host" => "x" },  { "host" => "y" } ] }
+      it { should_not raise_error }
+    end
+
+    context "(different values)" do
+      let(:a) { [ { "host" => "x" },  { "host" => "y" } ] }
+      let(:b) { [ { "host" => "x" },  { "host" => "z" } ] }
+      it { should raise_error(Must::ValueMismatch) }
+    end
+
+    context "(different struct)" do
+      let(:a) { [ { "host" => "x" },  { "host" => "y" } ] }
+      let(:b) { [ [ "host",   "x" ],  [ "host" ,  "y" ] ] }
+      it { should raise_error(Must::StructMismatch) }
+    end
+  end
+
+end

data/spec/duck_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Must::Rule, "duck" do
+  class CFoo
+    def foo; 1; end
+  end
+
+  module MFoo
+    def foo; 1; end
+  end
+
+  describe "duck typing test" do
+    specify "[OK]" do
+      1.must.duck(:to_s  ).should == 1
+      1.must.duck("to_s" ).should == 1
+      1.must.duck(".to_s").should == 1
+
+      CFoo.must.duck(:to_s  ).should == CFoo
+      CFoo.must.duck("to_s" ).should == CFoo
+      CFoo.must.duck(".to_s").should == CFoo
+
+      MFoo.must.duck(:to_s  ).should == MFoo
+      MFoo.must.duck("to_s" ).should == MFoo
+      MFoo.must.duck(".to_s").should == MFoo
+    end
+
+    specify "[NG]" do
+      lambda { 1.must.duck(:foo  ) }.should raise_error(Must::Invalid)
+      lambda { 1.must.duck("foo" ) }.should raise_error(Must::Invalid)
+      lambda { 1.must.duck(".foo") }.should raise_error(Must::Invalid)
+        
+      lambda { CFoo.must.duck(:foo  ) }.should raise_error(Must::Invalid)
+      lambda { CFoo.must.duck("foo" ) }.should raise_error(Must::Invalid)
+      lambda { CFoo.must.duck(".foo") }.should raise_error(Must::Invalid)
+
+      lambda { MFoo.must.duck(:foo  ) }.should raise_error(Must::Invalid)
+      lambda { MFoo.must.duck("foo" ) }.should raise_error(Must::Invalid)
+      lambda { MFoo.must.duck(".foo") }.should raise_error(Must::Invalid)
+    end
+  end
+
+  context "(instance duck typing)" do
+    specify "[OK]" do
+      CFoo.must.duck("#foo").should == CFoo
+      MFoo.must.duck("#foo").should == MFoo
+    end
+
+    specify "[NG]" do
+      lambda { 1.must.duck("#bar")    }.should raise_error(Must::Invalid)
+      lambda { CFoo.must.duck("#bar") }.should raise_error(Must::Invalid)
+      lambda { MFoo.must.duck("#bar") }.should raise_error(Must::Invalid)
+    end
+  end
+
+  context "(duck bang)" do
+    specify "[OK]" do
+      1.must.duck!("to_s").should == "1"
+    end
+
+    specify "[NG]" do
+      lambda { 1.must.duck!("foo") }.should raise_error(Must::Invalid)
+    end
+
+    specify "callback" do
+      1.must.duck!("to_xxx") { 2 }
+    end
+  end
+end

data/spec/match_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Must::Rule, "match" do
+  specify "[OK]" do
+    1.must.match(0..3).should == 1
+    'b'.must.match('a'..'c').should == 'b'
+  end
+
+  specify "[NG]" do
+    lambda { 1.must.match(2..3) }.should raise_error(Must::Invalid)
+    lambda { 'a'.must.match('y'..'z') }.should raise_error(Must::Invalid)
+  end
+end

data/spec/must_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Must::Rule, "must" do
+  def ok(&block)
+    block.should_not raise_error
+  end
+
+  def ng(error = Must::Invalid, &block)
+    block.should raise_error(error)
+  end
+
+  ######################################################################
+  ### must be
+
+  describe "be" do
+    specify "[OK]" do
+      1.must.be(1).should == 1
+      [1,2,3].must.be([1,2,3]).should == [1,2,3]
+      {:a=>1, "b"=>2}.must.be({:a=>1, "b"=>2}).should == {:a=>1, "b"=>2}
+      String.must.be(String).should == String
+    end
+
+    specify "[NG]" do
+      ng {1.must.be 2}
+    end
+
+    specify "callback" do
+      1.must.be(2){:error}.should == :error
+    end
+  end
+
+  ######################################################################
+  ### must not be blank
+
+  describe "not be blank" do
+    if Object.instance_methods.include?("blank?")
+      specify do
+        "ok".must.not.be.blank.should == "ok"
+        "ok".must.not.be.blank{"ng"}.should == "ok"
+        "".must.not.be.blank{"ng"}.should == "ng"
+        ng { "".must.not.be.blank }
+      end
+    end
+  end
+
+
+  ######################################################################
+  ### must(type)
+
+  describe "type" do
+    specify do
+      "ok".must(String).should == "ok"
+      "ok".must(Integer, String).should == "ok"
+      ng { "ok".must(Integer) }
+    end
+
+    specify "weird but it is" do
+      # NOTE: this passes because 1(integer) is a kind of 2(integer)
+      ok { 1.must(2) }
+    end
+
+    specify "callback" do
+      "ok".must(Integer){:error}.should == :error
+    end
+  end
+
+  ######################################################################
+  ### kind_of
+
+  describe "kind_of" do
+    specify do
+      "ok".must.be.kind_of(String).should == "ok"
+      ng {"ok".must.be.kind_of(Integer)}
+    end
+
+    specify "multiple args" do
+      "ok".must.be.kind_of(Integer,String).should == "ok"
+      "ok".must.be.kind_of(String,Integer).should == "ok"
+      ng { "ok".must.be.kind_of(Integer, Array) }
+    end
+
+    context "(class)" do
+      module KindOfTest
+        module Core; end
+        class Base
+          include Core
+        end
+      end
+
+      specify "check ancestors when module given" do
+        ok { KindOfTest::Base.must.be.kind_of(KindOfTest::Core) }
+        ng { KindOfTest::Base.must.be.kind_of(Numeric) }
+      end
+    end
+  end
+end

data/spec/struct_info_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Must::StructInfo do
+  def struct(obj)
+    Must::StructInfo.new(obj)
+  end
+
+  ######################################################################
+  ### same?
+
+  describe "#same?" do
+    specify do
+      struct(1      ).same?(Integer).should == true
+      struct(1      ).same?(Numeric).should == true
+      struct(String ).same?(Integer).should == false
+
+      struct(Integer).same?(Integer).should == true
+      struct(Integer).same?(Numeric).should == true
+      struct(Fixnum ).same?(1      ).should == true
+    end
+  end
+
+  ######################################################################
+  ### types
+
+  describe "#types" do
+    specify do
+      struct(1).types.should == [Fixnum]
+      struct(:a=>{"1"=>0.25}).types.should == [Hash, Symbol, String, Float]
+    end
+  end
+
+  ######################################################################
+  ### struct
+
+  describe "#compact" do
+    specify do
+      struct(1  ).compact.should == Fixnum
+      struct({} ).compact.should == Hash
+      struct([] ).compact.should == Array
+      struct([1]).compact.should == [Fixnum]
+
+      struct( "a"=>1       ).compact.should == {String=>Fixnum}
+      struct( [{"1"=>0.2}] ).compact.should == [{String=>Float}]
+
+      struct( "1.1" => {"jp"=>[{:a=>0},{:b=>2}]} ).compact.should == {String=>{String=>[{Symbol=>Fixnum}]}}
+    end
+
+    specify "array is represented by first element for speed" do
+      struct([1, "a"]).compact.should == [Fixnum]
+      struct(["a", 1]).compact.should == [String]
+    end
+  end
+
+  ######################################################################
+  ### inspect
+
+  describe "#inspect" do
+    specify do
+      struct(1  ).inspect.should == "Fixnum"
+      struct({} ).inspect.should == "Hash"
+      struct([] ).inspect.should == "Array"
+      struct([1]).inspect.should == "[Fixnum]"
+
+      struct( "a"=>1   ).inspect.should == "{String=>Fixnum}"
+      struct(["1"=>0.1]).inspect.should == "[{String=>Float}]"
+
+      struct( "1.1" => {"jp"=>[{:a=>0},{:b=>2}]} ).inspect.should == "{String=>{String=>[{Symbol=>Fixnum}]}}"
+    end
+  end
+
+end

data/spec/struct_spec.rb

@@ -1,11 +1,122 @@
 require 'spec_helper'
 
-describe Must do
+describe Must, "struct" do
   let(:obj) { {"xyz" => ["a","b"] } }
 
-  specify "show more info about struct differs" do
-    lambda {
-      obj.must.struct({String => [Hash]})
-    }.should raise_error(/expected \{String=>\[Hash\]/)
+  def ok(type) obj.must.struct?(type) == true ; end
+  def ng(type) obj.must.struct?(type) == false; end
+
+  ######################################################################
+  ### error message
+
+  describe "#struct" do
+    subject { lambda { obj.must.struct({String => [Hash]}) } }
+
+    it { should raise_error(Must::StructMismatch) }
+    it { should raise_error(/\{String=>\[Hash\]\}/) }
+  end
+
+  ######################################################################
+  ### basic object
+
+  describe "basic object" do
+    context "[]" do
+      let(:obj) { [] }
+      specify do
+        ok []
+        ng({})
+      end
+    end
+
+    context "1" do
+      let(:obj) { 1 }
+      specify do
+        ok Integer
+        ok Fixnum
+        ok 2
+        ng String
+      end
+    end
+
+    context "Fixnum" do
+      let(:obj) { Fixnum }
+      specify do
+        ok Fixnum
+        ok 2
+      end
+    end
+
+    context "Integer" do
+      let(:obj) { Integer }
+      specify do
+        ng Fixnum
+      end
+    end
+  end
+
+  describe "composite object" do
+    context "(simple hash)" do
+      let(:obj) { {"foo" => 1} }
+
+      specify do
+        ok String => Integer
+        ng String
+        ng Array
+        ng [String]
+        ng String => String
+      end
+    end
+
+    context "([Hash])" do
+      let(:obj) { [{:a=>1}, {:a=>3}] }
+
+      specify do
+        ok [Hash]
+        ng [Array]
+      end
+    end
+
+    context "(Hash(String, Array(Hash)))" do
+      let(:obj) { {"foo" => [{:a=>1}, {:a=>3}]} }
+
+      specify do
+        ok Hash
+        ng Array
+        ok String => Array
+        ng Array => Array
+        ok String => [Hash]
+      end
+    end
+
+
+    context "(Hash(String, Array(Hash)))" do
+      let(:obj) { {"foo" => [{:a=>1}, {:a=>3}]} }
+
+      specify do
+        ok String => []
+        ok String => Array
+        ng String => Hash
+        ok String => [Hash]
+
+        ok String => Array(Hash)
+        ng String => [Array]
+        ng String => Array(String)
+      end
+    end
+
+    context "(accept {String => [Hash]})" do
+      def ok(obj); obj.must.struct?({String => [Hash]}).should == true ; end
+      def ng(obj); obj.must.struct?({String => [Hash]}).should == false; end
+
+      specify do
+        ok({})
+        ng []
+        ok "foo" => []
+        ng "foo" => {"gp"=>"-1"}
+        ok "foo" => [{"gp"=>"-1"}]
+        ok "foo" => [{"sid"=>"45064"}, {"gp"=>"-1"}]
+        ng "foo" => [[{"sid"=>"45064"}]]
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: must
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 2
-  - 8
-  version: 0.2.8
+  - 9
+  version: 0.2.9
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-02-22 00:00:00 Z
+date: 2013-08-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -41,24 +41,26 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .gitignore
 - Gemfile
 - README
 - Rakefile
 - init.rb
 - install.rb
 - lib/must.rb
+- lib/must/differ.rb
 - lib/must/rule.rb
 - lib/must/struct_info.rb
 - lib/must/version.rb
 - must.gemspec
+- spec/coerced_spec.rb
+- spec/differ_spec.rb
+- spec/duck_spec.rb
+- spec/match_spec.rb
+- spec/must_spec.rb
 - spec/spec_helper.rb
+- spec/struct_info_spec.rb
 - spec/struct_spec.rb
-- test/coerced_test.rb
-- test/duck_test.rb
-- test/match_test.rb
-- test/must_test.rb
-- test/struct_info_test.rb
-- test/struct_test.rb
 homepage: http://github.com/maiha/must
 licenses: []
 

data/test/coerced_test.rb

@@ -1,39 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../init')
-
-class CoercedTest < Test::Unit::TestCase
-  def test_is_a_feature
-    assert_equal 1, 1.must.be.coerced(Integer)
-    assert_equal 1, 1.must.be.coerced(Integer, String)
-    assert_equal 1, 1.must.be.coerced(String, Numeric)
-
-    assert_raises(Invalid)     { "1".must.be.coerced(Integer) }
-    assert_raises(Invalid)     { "1".must.be.coerced(Integer, Range) }
-    assert_raises(NotImplementedError) { "1".must.be.coerced(Integer){raise NotImplementedError} }
-  end
-
-  def test_coecing_succeeded
-    assert_equal 1,   1.must.be.coerced(Integer, String=>proc{|i|i.to_i})
-    assert_equal 1, "1".must.be.coerced(Integer, String=>proc{|i|i.to_i})
-    assert_equal 1, "1".must.be.coerced(Integer, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
-    assert_equal 1, "1".must.be.coerced(Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
-    assert_equal 1, "1".must.be.coerced(File, Integer, Range, String=>proc{|i|i.to_i}, Range=>proc{|i|i.first})
-  end
-
-  def test_coecing_failed
-    assert_raises(Invalid)     { "1".must.be.coerced(Integer, String=>proc{|i| /a/}) }
-    assert_raises(NotImplementedError) { "1".must.be.coerced(Integer, String=>proc{|i| /a/}){raise NotImplementedError} }
-  end
-
-  def test_cascaded_coecing_succeeded
-    assert_equal 1,    1.must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
-    assert_equal 1,  "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
-    assert_equal 1, :"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:to_i)
-  end
-
-  def test_detect_livelock
-    assert_raises(Invalid){ "1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}
-    assert_raises(Invalid){:"1".must.be.coerced(Integer, Symbol=>:to_s, String=>:intern)}
-  end
-end

data/test/duck_test.rb

@@ -1,97 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../init')
-
-class DuckTest < Test::Unit::TestCase
-  class ClassFoo
-    def foo; 1; end
-  end
-
-  module ModuleFoo
-    def foo; 1; end
-  end
-
-  def test_itself_duck_type
-    # succeeded
-    assert_equal 1, 1.must.duck(:to_s)
-    assert_equal 1, 1.must.duck("to_s")
-    assert_equal 1, 1.must.duck(".to_s")
-    assert_equal ClassFoo, ClassFoo.must.duck(:to_s)
-    assert_equal ClassFoo, ClassFoo.must.duck("to_s")
-    assert_equal ClassFoo, ClassFoo.must.duck(".to_s")
-    assert_equal ModuleFoo, ModuleFoo.must.duck(:to_s)
-    assert_equal ModuleFoo, ModuleFoo.must.duck("to_s")
-    assert_equal ModuleFoo, ModuleFoo.must.duck(".to_s")
-
-    # failed
-    assert_raises(Invalid) { 1.must.duck(:foo) }
-    assert_raises(Invalid) { 1.must.duck("foo") }
-    assert_raises(Invalid) { 1.must.duck(".foo") }
-    assert_raises(Invalid) { ClassFoo.must.duck(:foo) }
-    assert_raises(Invalid) { ClassFoo.must.duck("foo") }
-    assert_raises(Invalid) { ClassFoo.must.duck(".foo") }
-    assert_raises(Invalid) { ModuleFoo.must.duck(:foo) }
-    assert_raises(Invalid) { ModuleFoo.must.duck("foo") }
-    assert_raises(Invalid) { ModuleFoo.must.duck(".foo") }
-  end
-
-  def test_instance_duck_type
-    # succeeded
-    assert_equal ClassFoo, ClassFoo.must.duck("#foo")
-    assert_equal ModuleFoo, ModuleFoo.must.duck("#foo")
-
-    # failed
-    assert_raises(Invalid) { 1.must.duck("#bar") } # instance object
-    assert_raises(Invalid) { ClassFoo.must.duck("#bar") }
-    assert_raises(Invalid) { ModuleFoo.must.duck("#bar") }
-  end
-
-  def test_itself_duck_test
-    # succeeded
-    assert_equal true, 1.must.duck?(:to_s)
-    assert_equal true, 1.must.duck?("to_s")
-    assert_equal true, 1.must.duck?(".to_s")
-    assert_equal true, ClassFoo.must.duck?(:to_s)
-    assert_equal true, ClassFoo.must.duck?("to_s")
-    assert_equal true, ClassFoo.must.duck?(".to_s")
-    assert_equal true, ModuleFoo.must.duck?(:to_s)
-    assert_equal true, ModuleFoo.must.duck?("to_s")
-    assert_equal true, ModuleFoo.must.duck?(".to_s")
-
-    # failed
-    assert_equal false, 1.must.duck?(:foo)
-    assert_equal false, 1.must.duck?("foo")
-    assert_equal false, 1.must.duck?(".foo")
-    assert_equal false, ClassFoo.must.duck?(:foo)
-    assert_equal false, ClassFoo.must.duck?("foo")
-    assert_equal false, ClassFoo.must.duck?(".foo")
-    assert_equal false, ModuleFoo.must.duck?(:foo)
-    assert_equal false, ModuleFoo.must.duck?("foo")
-    assert_equal false, ModuleFoo.must.duck?(".foo")
-  end
-
-  def test_instance_duck_test
-    # succeeded
-    assert_equal true, ClassFoo.must.duck?("#foo")
-    assert_equal true, ModuleFoo.must.duck?("#foo")
-
-    # failed
-    assert_equal false, 1.must.duck?("#bar") # instance object
-    assert_equal false, ClassFoo.must.duck?("#bar")
-    assert_equal false, ModuleFoo.must.duck?("#bar")
-  end
-
-  def test_duck_bang
-    assert_equal "1", 1.must.duck!("to_s")
-  end
-
-  def test_duck_bang_raises_if_not_defined
-    assert_raise(Must::Invalid) {
-      ClassFoo.must.duck!("foo")
-    }
-  end
-
-  def test_duck_bang_calls_block_if_not_defined
-    assert_equal 2, 1.must.duck!("to_xxx") { 2 }
-  end
-end

data/test/match_test.rb

@@ -1,15 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../init')
-
-class MatchTest < Test::Unit::TestCase
-  def test_match_range
-    # succeeded
-    assert_equal 1, 1.must.match(0..3)
-    assert_equal 'b', 'b'.must.match('a'..'c')
-
-    # failed
-    assert_raises(Invalid) { 1.must.match(2..3) }
-    assert_raises(Invalid) { 'a'.must.match('y'..'z') }
-  end
-end

data/test/must_test.rb

@@ -1,64 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../init')
-
-class MustTest < Test::Unit::TestCase
-
-  ######################################################################
-  ### must be
-
-  def test_must_be
-    assert_nothing_raised {1.must.be 1}
-    assert_nothing_raised {[1,2,3].must.be [1,2,3]}
-    assert_nothing_raised {{:a=>1, "b"=>2}.must.be({:a=>1, "b"=>2})}
-    assert_nothing_raised {String.must.be String}
-  end
-
-  def test_must_be_error
-    assert_raises(Invalid) {1.must.be 2}
-  end
-
-  def test_must_be_with_block
-    assert_equal :error, 1.must.be(2) {:error}
-  end
-
-  def test_must_not_be_blank
-    if Object.instance_methods.include?("blank?")
-      assert_equal "ok", "ok".must.not.be.blank
-      assert_equal "ok", "ok".must.not.be.blank {"ng"}
-      assert_equal "ng",   "".must.not.be.blank {"ng"}
-      assert_raises(Invalid) {"".must.not.be.blank}
-    end
-  end
-
-  ######################################################################
-  ### must(xxx)
-
-  def test_must_accepts_args_as_kind_of
-    assert_equal "ok", "ok".must(String)
-    assert_raises(Invalid) {"ok".must(Integer)}
-    assert_equal "ok", "ok".must(Integer, String)
-
-    # NOTE: this passes because 1(integer) is a kind of 2(integer)
-    assert_equal 1, 1.must(2)
-  end
-
-  def test_must_with_block
-    assert_equal :error, "ok".must(Integer) {:error}
-  end
-
-  ######################################################################
-  ### kind_of
-
-  def test_kind_of
-    assert_equal "ok", "ok".must.be.kind_of(String)
-    assert_raises(Invalid) {"ok".must.be.kind_of(Integer)}
-  end
-
-  def test_kind_of_several_args
-    assert_equal "ok", "ok".must.be.kind_of(Integer,String)
-    assert_equal "ok", "ok".must.be.kind_of(String,Integer)
-    assert_raises(Invalid) {"ok".must.be.kind_of(Integer, Array)}
-  end
-end
-

data/test/struct_info_test.rb

@@ -1,57 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../init')
-
-class StructInfoTest < Test::Unit::TestCase
-  ######################################################################
-  ### same?
-
-  def test_same_p
-    assert   Must::StructInfo.new(1).same?(Integer)
-    assert   Must::StructInfo.new(1).same?(Numeric)
-    assert ! Must::StructInfo.new(1).same?(String)
-
-    assert   Must::StructInfo.new(Integer).same?(Integer)
-    assert   Must::StructInfo.new(Integer).same?(Numeric)
-    assert   Must::StructInfo.new(Fixnum).same?(1)
-  end
-
-  ######################################################################
-  ### types
-
-  def test_types
-    assert_equal [Fixnum], Must::StructInfo.new(1).types
-    assert_equal [Hash, Symbol, String, Float], Must::StructInfo.new({:a=>{"1"=>0.25}}).types
-  end
-
-  ######################################################################
-  ### struct
-
-  def test_compact
-    assert_equal(Fixnum, Must::StructInfo.new(1).compact)
-    assert_equal(Hash, Must::StructInfo.new({}).compact)
-    assert_equal(Array, Must::StructInfo.new([]).compact)
-    assert_equal([Fixnum], Must::StructInfo.new([1]).compact)
-    assert_equal({String=>Fixnum}, Must::StructInfo.new({"a"=>1}).compact)
-    assert_equal([{String=>Float}], Must::StructInfo.new([{"1"=>0.25}]).compact)
-    assert_equal({String=>{String=>[{Symbol=>Fixnum}]}}, Must::StructInfo.new({"1.1" => {"jp"=>[{:a=>0},{:b=>2}]}}).compact)
-  end
-
-  def test_compact_array_into_first_element
-    assert_equal [Fixnum], Must::StructInfo.new([1, "a"]).compact
-    assert_equal [String], Must::StructInfo.new(["a", 1]).compact
-  end
-
-  ######################################################################
-  ### pp
-
-  def test_inspect
-    assert_equal "Fixnum", Must::StructInfo.new(1).inspect
-    assert_equal "Hash", Must::StructInfo.new({}).inspect
-    assert_equal "Array", Must::StructInfo.new([]).inspect
-    assert_equal "[Fixnum]", Must::StructInfo.new([1]).inspect
-    assert_equal "{String=>Fixnum}", Must::StructInfo.new({"a"=>1}).inspect
-    assert_equal "[{String=>Float}]", Must::StructInfo.new([{"1"=>0.25}]).inspect
-    assert_equal "{String=>{String=>[{Symbol=>Fixnum}]}}", Must::StructInfo.new({"1.1" => {"jp"=>[{:a=>0},{:b=>2}]}}).inspect
-  end
-end

data/test/struct_test.rb

@@ -1,64 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../init')
-
-class StructTest < Test::Unit::TestCase
-  def test_struct_basic_object
-    assert   [].must.struct?([])
-    assert ! [].must.struct?({})
-
-    assert   1.must.struct?(Integer)
-    assert   1.must.struct?(Fixnum)
-    assert   1.must.struct?(2)
-    assert ! 1.must.struct?(String)
-    assert   Fixnum.must.struct?(Fixnum)
-    assert   Fixnum.must.struct?(2)
-    assert ! Integer.must.struct?(Fixnum)
-  end
-
-  def test_struct_composite_objects
-    obj = {"foo" => 1}
-    assert   obj.must.struct?({String => Integer})
-    assert ! obj.must.struct?(String)
-    assert ! obj.must.struct?(Array)
-    assert ! obj.must.struct?([String])
-    assert ! obj.must.struct?({String => String})
-
-    obj = [{:a=>1}, {:a=>3}]
-    assert   obj.must.struct?([Hash])
-    assert ! obj.must.struct?([Array])
-
-    obj = {"foo" => [{:a=>1}, {:a=>3}]}
-    assert   obj.must.struct?(Hash)
-    assert ! obj.must.struct?(Array)
-    assert   obj.must.struct?({String => Array})
-    assert ! obj.must.struct?({Array => Array})
-    assert   obj.must.struct?({String => [Hash]})
-
-    obj = {"foo" => [{:a=>1}, {:a=>3}]}
-    assert   obj.must.struct?({String => []})
-    assert   obj.must.struct?({String => Array})
-    assert ! obj.must.struct?({String => Hash})
-    assert   obj.must.struct?({String => [Hash]})
-    assert   obj.must.struct?({String => Array(Hash)})
-    assert ! obj.must.struct?({String => [Array]})
-    assert ! obj.must.struct?({String => Array(String)})
-  end
-
-  def test_struct_complicated
-    def ok(obj)
-      assert_equal obj, obj.must.struct({String => [Hash]})
-    end
-    def ng(obj)
-      assert_raises(Invalid){ obj.must.struct({String => [Hash]})}
-    end
-
-    ok({})
-    ng []
-    ok "foo" => []
-    ng "foo" => {"gp"=>"-1"}
-    ok "foo" => [{"gp"=>"-1"}]
-    ok "foo" => [{"sid"=>"45064"}, {"gp"=>"-1"}]
-    ng "foo" => [[{"sid"=>"45064"}]]
-  end
-end