must 0.2.4 → 0.2.5

data/README

@@ -148,6 +148,20 @@ NOTE
   Fixnum.must(1)   # => Fixnum
 
 
+Bundled Class
+=============
+
+  struct = Must::StructInfo.new({"1.1" => {"jp"=>[{:a=>0},{:b=>2}]}})
+  struct.types   # => [Hash, String, Array, Symbol, Fixnum]
+  struct.compact # => {String=>{String=>[{Symbol=>Fixnum}]}}
+  struct.inspect # => "{String=>{String=>[{Symbol=>Fixnum}]}}"
+
+
+TODO
+====
+  * add proper error messages
+
+
 Install
 =======
   gem install must

data/lib/must/rule.rb

@@ -1,5 +1,5 @@
 require 'set'
-require "must/same_struct"
+require "must/struct_info"
 
 module Must
   class Rule
@@ -39,12 +39,13 @@ module Must
       be(nil, &block)
     end
 
-    def kind_of(*targets)
+    def kind_of(*targets, &block)
       bool = targets.any?{|klass| is_a?(klass)}
-      valid?(bool) {
+      block ||= proc {
         target = targets.map{|i| instance?(i) ? i.class.name : i.name}.join('/')
         raise Invalid, "expected #{target} but got #{object.class}"
       }
+      valid?(bool, &block)
     end
 
     def one_of(target, &block)
@@ -89,7 +90,7 @@ module Must
     end
 
     def struct?(target)
-      Must::SameStruct.check(@object, target)
+      Must::StructInfo.new(@object).same?(target)
     end
 
     def struct(target, &block)

data/lib/must/struct_info.rb

@@ -0,0 +1,101 @@
+module Must
+  class StructInfo
+
+    module Classify
+      def classify(obj)
+        class?(obj) ? obj : obj.class
+      end
+
+      def class?(obj)
+        obj.class.to_s =~ /\A(Class|Module)\Z/o
+      end
+    end
+
+    module Browser
+      include Classify
+
+      def compact(obj)
+        case obj
+        when Hash
+          Hash[*(obj.first || []).map{|i| compact(i)}]
+        when Array
+          obj.empty? ? [] : [compact(obj.first)]
+        else
+          classify(obj)
+        end
+      end
+
+      def types(obj)
+        case obj
+        when Hash
+          ([Hash] + (obj.first || []).map{|i| types(i)}.flatten).uniq
+        when Array
+          ([Array] + obj.map{|i| types(i)}.flatten).uniq
+        else
+          [classify(obj)]
+        end
+      end
+
+      def same?(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
+
+      extend self
+    end
+
+    ######################################################################
+    ### StructInfo
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def types
+      Browser.types(@obj)
+    end
+
+    def compact
+      Browser.compact(@obj)
+    end
+
+    def same?(dst)
+      Browser.same?(@obj, dst)
+    end
+
+    def inspect
+      compact.inspect
+    end
+  end
+end

data/lib/must/version.rb

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

data/lib/must.rb

@@ -5,9 +5,9 @@ module Must
   class Invalid < StandardError; end
   class ShouldNotEmpty  < Invalid; end
 
-  def must(*args)
+  def must(*args, &block)
     if args.size > 0
-      Rule.new(self).be.kind_of(*args)
+      Rule.new(self).be.kind_of(*args, &block)
     else
       Rule.new(self)
     end

data/test/must_test.rb

@@ -4,6 +4,9 @@ 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]}
@@ -28,6 +31,9 @@ class MustTest < Test::Unit::TestCase
     end
   end
 
+  ######################################################################
+  ### must(xxx)
+
   def test_must_accepts_args_as_kind_of
     assert_equal "ok", "ok".must(String)
     assert_raises(Invalid) {"ok".must(Integer)}
@@ -36,5 +42,23 @@ class MustTest < Test::Unit::TestCase
     # 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

@@ -0,0 +1,53 @@
+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({}, Must::StructInfo.new({}).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 "{}", Must::StructInfo.new({}).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

@@ -3,39 +3,46 @@ 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)
+  def test_struct_basic_object
+    assert   [].must.struct?([])
+    assert ! [].must.struct?({})
 
-    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]})
+    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_test_failed
-    assert_equal false, [].must.struct?({})
-    assert_equal false, Integer.must.struct?(Fixnum)
-
+  def test_struct_composite_objects
     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})
+    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_equal false, obj.must.struct?([Array])
+    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_equal false, obj.must.struct?({String => Hash})
-    assert_equal false, obj.must.struct?({String => [Array]})
+    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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: must
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 2
-  - 4
-  version: 0.2.4
+  - 5
+  version: 0.2.5
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-27 00:00:00 +09:00
+date: 2012-02-09 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -35,13 +35,14 @@ files:
 - install.rb
 - lib/must.rb
 - lib/must/rule.rb
-- lib/must/same_struct.rb
+- lib/must/struct_info.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_info_test.rb
 - test/struct_test.rb
 has_rdoc: true
 homepage: http://github.com/maiha/must

data/lib/must/same_struct.rb

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