must 0.2.3 → 0.2.4

data/README

@@ -1,7 +1,6 @@
 Must
 ====
-
-add Object#must method to constrain its origin and conversions
+  add Object#must method to constrain its origin and conversions
 
   # can write like this
     num = params[:num].to_i.must.match(1..300) {10}
@@ -10,80 +9,93 @@ add Object#must method to constrain its origin and conversions
     num = params[:num].to_i
     num = 10 unless (1..300) === num
 
-and has duck features
+  and has duck-type features
 
     1.must.duck?(:to_s)  # => true
     io.must.duck(:write) { io.extend Writable }
 
+  and has struct assetions
+
+    pages = [{:name=>"...", :url=>"...",} ...]
+    pages.must.struct([Hash])
+
 
 Asking Methods
 ==============
-
-be      : check whether object equals to the argument
-kind_of : check whether object is a kind of the arguments
-coerced : check whether object can be coerced to the argument
-blank   : check whether object is blank?
-exist   : check whether object is not nil (NOTE: false is ok)
+  be      : check whether object equals to the argument
+  kind_of : check whether object is a kind of the arguments
+  coerced : check whether object can be coerced to the argument
+  blank   : check whether object is blank?
+  exist   : check whether object is not nil (NOTE: false is ok)
 
 
 Logical Methods
 ===============
-
-not : logical NOT
+  not : logical NOT
 
 
 Nop Methods
 ===========
-
-a  : return self
-an : return self
+  a  : return self
+  an : return self
 
 These effect nothing but exist only for English grammar.
 
 
 Duck Methods
 ============
-duck("foo")  : check whether object responds to "foo" method.
-duck(:foo)   : same above
-duck(".foo") : same above
-duck("#foo") : check whether object has "foo" instance method. (tested only in class/module)
-duck?(...)   : acts same as "duck", but this returns a just boolean
+  duck("foo")  : check whether object responds to "foo" method.
+  duck(:foo)   : same above
+  duck(".foo") : same above
+  duck("#foo") : check whether object has "foo" instance method. (tested only in class/module)
+  duck?(...)   : acts same as "duck", but this returns a just boolean
+
+
+Struct Methods
+============
+  struct(...)  : check whether object has a same struct with ...
+  struct?(...) : acts same as "struct", but this returns a just boolean
 
 
 Basic Examples
 ==============
 
 # test its value exactly
-1.must.be 1              # => 1
-[1,2,3].must.be [1,2,3]  # => [1,2,3]
+  1.must.be 1              # => 1
+  [1,2,3].must.be [1,2,3]  # => [1,2,3]
 
 # exceptions
-1.must.be []             # Must::Invalid exception
-1.must.be([]) {:ng}      # => :ng
-1.must.be(1) {:ng}       # => 1
+  1.must.be []             # Must::Invalid exception
+  1.must.be([]) {:ng}      # => :ng
+  1.must.be(1) {:ng}       # => 1
 
 # as default value
-name = params[:name].must.not.be.blank{ "No name" }
+  name = params[:name].must.not.be.blank{ "No name" }
 
 # existing test
-1.must.exist             # => 1
-nil.must.exist           # Must::Invalid exception
-false.must.exist         # => false
+  1.must.exist             # => 1
+  nil.must.exist           # Must::Invalid exception
+  false.must.exist         # => false
 
 # test class : ensures that a class of the object is one of given arguments
-1.must.be.kind_of(Integer)         # => 1
-1.must.be.kind_of(Integer, Array)  # => 1
-[].must.be.kind_of(Integer, Array) # => []
-1.must.be.kind_of(String, Array)   # Must::Invalid: expected String/Array but got Fixnum
+  1.must.be.kind_of(Integer)         # => 1
+  1.must.be.kind_of(Integer, Array)  # => 1
+  [].must.be.kind_of(Integer, Array) # => []
+  1.must.be.kind_of(String, Array)   # Must::Invalid: expected String/Array but got Fixnum
 
 # must(*args) is a syntax sugar for kind_of
-1.must(Integer)          # same as "1.must.be.kind_of(Integer)"
+  1.must(Integer)          # same as "1.must.be.kind_of(Integer)"
 
 # coercing : looks like kind_of except converting its value if possible
-1.must.be.coerced(Integer, String => proc{|val| val.to_i})    # => 1
-"1".must.be.coerced(Integer, String => proc{|val| val.to_i})  # => 1
-"1".must.be.coerced(Integer, String => :to_i)                 # => 1     (NOTE: inline Symbol means sending the method)
-"1".must.be.coerced(Integer, Symbol, String => proc{:to_i})   # => :to_i (NOTE: use proc to return Symbol itself)
+  1.must.be.coerced(Integer, String => proc{|val| val.to_i})    # => 1
+  "1".must.be.coerced(Integer, String => proc{|val| val.to_i})  # => 1
+  "1".must.be.coerced(Integer, String => :to_i)                 # => 1     (NOTE: inline Symbol means sending the method)
+  "1".must.be.coerced(Integer, Symbol, String => proc{:to_i})   # => :to_i (NOTE: use proc to return Symbol itself)
+
+# struct assertions
+
+  uris = build_uris		# ex) [{:host=>"...", :port=>"..."}, ...]
+  uris.must.struct([Hash])
 
 
 Actual Examples
@@ -125,24 +137,31 @@ Actual Examples
   DateFolder.new "2008-12-9"
 
 
+NOTE
+====
+"must(*args)" is a shortcut for not "be(*args)" but "kind_of(*args)" and "struct(*args)".
+
+  1.must(1)        # => 1
+  1.must(Fixnum)   # => 1
+  1.must(2)        # => 1    # NOTE
+  1.must.be(2)     # Invalid
+  Fixnum.must(1)   # => Fixnum
+
+
 Install
 =======
+  gem install must
 
-gem install must
-
-% irb -r rubygems -r must
-irb(main):001:0> 1.must.be 1
-=> 1
+  % irb -r rubygems -r must
+  irb(main):001:0> 1.must.be 1
+  => 1
 
 
 Github
 ======
-
-http://github.com/maiha/must
+  http://github.com/maiha/must
 
 
 Author
 ======
-
-maiha@wota.jp
-
+  maiha@wota.jp

data/lib/must/rule.rb

@@ -1,4 +1,5 @@
 require 'set'
+require "must/same_struct"
 
 module Must
   class Rule
@@ -39,8 +40,9 @@ module Must
     end
 
     def kind_of(*targets)
-      valid?(targets.any?{|klass| object.is_a? klass}) {
-        target = targets.map{|i| i.name}.join('/')
+      bool = targets.any?{|klass| is_a?(klass)}
+      valid?(bool) {
+        target = targets.map{|i| instance?(i) ? i.class.name : i.name}.join('/')
         raise Invalid, "expected #{target} but got #{object.class}"
       }
     end
@@ -58,14 +60,6 @@ module Must
       end
     end
 
-    def block_or_throw(&block)
-      if block
-        block.call
-      else
-        raise Invalid
-      end
-    end
-
     def coerced(*types, &block)
       coecings        ||= types.last.is_a?(Hash) ? types.pop : {}
       already_coerced ||= Set.new
@@ -94,13 +88,21 @@ module Must
       end
     end
 
+    def struct?(target)
+      Must::SameStruct.check(@object, target)
+    end
+
+    def struct(target, &block)
+      valid?(struct?(target), &block)
+    end
+
     private
-      def instance?
-        @object.class.to_s !~ /\A(Class|Module)\Z/o
+      def instance?(obj)
+        obj.class.to_s !~ /\A(Class|Module)\Z/o
       end
 
       def instance_method_defined?(method_name)
-        return false if instance?
+        return false if instance?(@object)
         !! @object.instance_methods.find { |m| m.to_s == method_name.to_s}
       end
 
@@ -108,5 +110,21 @@ module Must
         @object.respond_to?(method_name)
       end
 
+      def is_a?(klass)
+        if instance?(klass)
+          struct?(klass)
+        else
+          @object.is_a? klass
+        end
+      end
+
+      def block_or_throw(&block)
+        if block
+          block.call
+        else
+          raise Invalid
+        end
+      end
+
   end
 end

data/lib/must/same_struct.rb

@@ -0,0 +1,47 @@
+module Must
+  module SameStruct
+    def self.check(src, dst)
+      case src
+      when Hash
+        return true if dst == Hash
+        dst.must(Hash)
+        return true if src.empty?
+        return true if dst.empty?
+        key1, val1 = src.first
+        key2, val2 = dst.first
+        key1.must(key2)
+        val1.must(val2)
+
+      when Array
+        return true if dst == Array
+        dst.must(Array)
+        return true if src.empty?
+        return true if dst.empty?
+        src.first.must(dst.first)
+
+      else
+        # 1.must.struct(2)
+        # 1.must.struct(Integer)
+        dst_class = classify(dst)
+        return true if classify(src).ancestors.include?(dst_class)
+
+        # Fixnum.must.struct(2)
+        return true if class?(src) and src.ancestors.include?(dst_class)
+
+        return false
+      end
+      return true
+
+    rescue Must::Invalid
+      return false
+    end
+
+    def self.classify(obj)
+      class?(obj) ? obj : obj.class
+    end
+
+    def self.class?(obj)
+      obj.class.to_s =~ /\A(Class|Module)\Z/o
+    end
+  end
+end

data/lib/must/version.rb

@@ -1,3 +1,3 @@
 module Must
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/test/must_test.rb

@@ -32,6 +32,9 @@ class MustTest < Test::Unit::TestCase
     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
 end
 

data/test/struct_test.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'rubygems'
+require File.join(File.dirname(__FILE__), '../init')
+
+class StructTest < Test::Unit::TestCase
+  def test_struct_test_successed
+    assert_equal true, [].must.struct?([])
+    assert_equal true, 1.must.struct?(Integer)
+    assert_equal true, 1.must.struct?(Fixnum)
+    assert_equal true, 1.must.struct?(2)
+    assert_equal true, Fixnum.must.struct?(Fixnum)
+    assert_equal true, Fixnum.must.struct?(2)
+
+    obj = {"foo" => 1}
+    assert_equal true, obj.must.struct?({String => Integer})
+
+    obj = {"foo" => [{:a=>1}, {:a=>3}]}
+    assert_equal true, obj.must.struct?(Hash)
+    assert_equal true, obj.must.struct?({String => Array})
+    assert_equal true, obj.must.struct?({String => [Hash]})
+  end
+
+  def test_struct_test_failed
+    assert_equal false, [].must.struct?({})
+    assert_equal false, Integer.must.struct?(Fixnum)
+
+    obj = {"foo" => 1}
+    assert_equal false, obj.must.struct?(String)
+    assert_equal false, obj.must.struct?(Array)
+    assert_equal false, obj.must.struct?([String])
+    assert_equal false, obj.must.struct?({String => String})
+
+    obj = [{:a=>1}, {:a=>3}]
+    assert_equal false, obj.must.struct?([Array])
+
+    obj = {"foo" => [{:a=>1}, {:a=>3}]}
+    assert_equal false, obj.must.struct?({String => Hash})
+    assert_equal false, obj.must.struct?({String => [Array]})
+  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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: must
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-26 00:00:00 +09:00
+date: 2012-01-27 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -35,12 +35,14 @@ files:
 - install.rb
 - lib/must.rb
 - lib/must/rule.rb
+- lib/must/same_struct.rb
 - lib/must/version.rb
 - must.gemspec
 - test/coerced_test.rb
 - test/duck_test.rb
 - test/match_test.rb
 - test/must_test.rb
+- test/struct_test.rb
 has_rdoc: true
 homepage: http://github.com/maiha/must
 licenses: []