must 0.3.0 → 0.3.1

data/lib/must.rb

@@ -9,6 +9,13 @@ module Must
 
   def must(*args, &block)
     if args.size > 0
+      # Fast type checking
+      args.each{|klass|
+        return self if self.class == klass  # 1.must(Fixnum)
+        return self if self       == klass  # flag.must(true, false)
+      }
+
+      # Or, check it in a slow but strict way
       Rule.new(self).be.kind_of(*args, &block)
     else
       Rule.new(self)

data/lib/must/differ.rb

@@ -2,7 +2,8 @@ module Must
   class Differ
     attr_reader :a, :b, :path
 
-    def initialize(a, b, path)
+    def initialize(a, b, path = nil)
+      path ||= a.class.name.downcase
       @a, @b, @path = a, b, path
     end
 
@@ -16,7 +17,11 @@ module Must
 
     def execute!
       unless a.class == b.class
-        failed ClassMismatch, "%s expected [%s], but got [%s]" % [path, a.class, b.class]
+        if a == nil or b == nil
+          failed ValueMismatch, "%s expected %s, but got %s" % [path, a.class, b.class]
+        else
+          failed ClassMismatch, "%s expected %s, but got %s" % [path, a.class, b.class]
+        end
       end
 
       if a.is_a?(Array)
@@ -29,7 +34,7 @@ module Must
 
       if a.is_a?(Hash)
         (a.keys | b.keys).each do |key|
-          Differ.new(a[key], b[key], "#{path}[#{key}]").execute!
+          Differ.new(a[key], b[key], "#{path}[#{key.inspect}]").execute!
         end
         return true
       end
@@ -43,16 +48,21 @@ module Must
       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]
+        if a.class == b.class
+          failed ValueMismatch, "%s expected %s, but got %s" % [path, av, bv]
+        else
+          failed ValueMismatch, "%s expected %s(%s), but got %s(%s)" % [path, av, a.class, bv, a.class]
+        end
       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]
+#        as = Must::StructInfo.new(a).inspect
+#        bs = Must::StructInfo.new(b).inspect
+#        raise Must::StructMismatch, "%s expected %s, but got %s" % [path, as, bs]
+        raise Must::StructMismatch, err.to_s
       else
         raise
       end
@@ -65,6 +75,13 @@ module Must
       return false
     end
 
+    def message
+      execute!
+      return nil
+    rescue Must::Invalid => err
+      return err.message
+    end
+
     def failed(klass, msg)
       raise klass, msg
     end

data/lib/must/rule.rb

@@ -110,7 +110,7 @@ module Must
     end
 
     def struct(target, &block)
-      block ||= proc{ Must::Differ.new(@object, target, "").execute! }
+      block ||= proc{ raise Must::StructMismatch, Differ.new(@object, target, "").message }
       valid?(struct?(target), &block)
     end
 

data/lib/must/version.rb

@@ -1,3 +1,3 @@
 module Must
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/spec/differ_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Must::Differ do
   let(:a) {}
   let(:b) {}
-  let(:path) { "obj" }
+  let(:path) { nil }
 
   subject { lambda { Must::Differ.new(a, b, path).execute! } }
 
@@ -67,4 +67,27 @@ describe Must::Differ do
     end
   end
 
+  context "complex object" do
+    let(:a) { {
+        "abc" => 0,
+        "xyz" => 1,
+      } }
+
+    let(:b) { {
+        "abc" => nil,
+        "xyz" => 1,
+      } }
+
+    it { should raise_error(Must::ValueMismatch) }
+
+    context "(with label)" do
+      let(:path) { "foo" }
+      it { should raise_error(/foo\["abc"\]/) }
+    end
+
+    context "(without label)" do
+      let(:path) { nil }
+      it { should raise_error(/hash\["abc"\]/) }
+    end
+  end
 end

data/spec/must_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Must::Rule, "must" do
+describe Must, "must" do
   def ok(&block)
     block.should_not raise_error
   end
@@ -9,88 +9,41 @@ describe Must::Rule, "must" do
     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
+  context "1.must(klass)" do
+    specify do
+      ok { 1.must(Integer) }
+      ok { 1.must(Integer, String) }
+      ok { 1.must(Fixnum) }
 
-  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
+      ng { 1.must(String)  }
+      ng { 1.must(String, Array)  }
     end
   end
 
-
-  ######################################################################
-  ### must(type)
-
-  describe "type" do
+  context "klass.must(klass)" do
     specify do
-      "ok".must(String).should == "ok"
-      "ok".must(Integer, String).should == "ok"
-      ng { "ok".must(Integer) }
-    end
+      ok { Fixnum.must(Fixnum) }
+      ok { Fixnum.must(Integer) }
+      ok { Fixnum.must(Numeric) }
+      ok { Fixnum.must(Integer, String) }
 
-    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
+      ng { Integer.must(Fixnum) }
+      ng { Integer.must(String)  }
+      ng { Integer.must(String, Array)  }
     end
   end
 
-  ######################################################################
-  ### kind_of
-
-  describe "kind_of" do
+  context "true.must(bool)" 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
+      ok { true.must(true) }
+      ok { true.must(true,false) }
+      ng { true.must(false) }
+      ng { "xx".must(true,false) }
+
+      ok { false.must(false) }
+      ok { false.must(true,false) }
+      ng { false.must(true) }
+      ng { "xxx".must(true,false) }
     end
   end
 end

data/spec/rule_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/spec_helper.rb

@@ -12,4 +12,7 @@ RSpec.configure do |config|
   # config.mock_with :flexmock
   # config.mock_with :rr
   config.mock_with :rspec
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
 end

data/spec/struct_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Must, "struct" do
-  let(:obj) { {"xyz" => ["a","b"] } }
-
   def ok(type) obj.must.struct?(type) == true ; end
   def ng(type) obj.must.struct?(type) == false; end
 
@@ -10,10 +8,11 @@ describe Must, "struct" do
   ### error message
 
   describe "#struct" do
+    let(:obj) { {"xyz" => ["a","b"] } }
     subject { lambda { obj.must.struct({String => [Hash]}) } }
 
     it { should raise_error(Must::StructMismatch) }
-    it { should raise_error(/\{String=>\[Hash\]\}/) }
+#    it { should raise_error(/\{String=>\[Hash\]\}/) }
   end
 
   ######################################################################
@@ -88,7 +87,6 @@ describe Must, "struct" do
       end
     end
 
-
     context "(Hash(String, Array(Hash)))" do
       let(:obj) { {"foo" => [{:a=>1}, {:a=>3}]} }
 
@@ -105,6 +103,8 @@ describe Must, "struct" do
     end
 
     context "(accept {String => [Hash]})" do
+      let(:obj) { {"xyz" => ["a","b"] } }
+
       def ok(obj); obj.must.struct?({String => [Hash]}).should == true ; end
       def ng(obj); obj.must.struct?({String => [Hash]}).should == false; end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: must
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-08-23 00:00:00 Z
+date: 2013-09-04 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -58,6 +58,7 @@ files:
 - spec/duck_spec.rb
 - spec/match_spec.rb
 - spec/must_spec.rb
+- spec/rule_spec.rb
 - spec/spec_helper.rb
 - spec/struct_info_spec.rb
 - spec/struct_spec.rb