typed 0.1.0 → 0.1.1

data/lib/typed/hash.rb

@@ -56,7 +56,18 @@ module Typed
     def []=(key, val)
       if check_schema?(key)
         if @schema.exist?(key)
+          case val
+          when LazyValue
+            # not schema
+          when [], {}
+            # not schema cause already declared
+          else
+            struct = Must::StructInfo.new(val).compact
+            # when schema format, try update schema
+            @schema[key] = val if struct == val
+          end
           @schema.check!(key, val)
+
         else
           case val
           when LazyValue
@@ -69,6 +80,7 @@ module Typed
           else
             struct = Must::StructInfo.new(val).compact
             @schema[key] = struct
+            # when schema format, just declare schema and return
             return if struct == val
           end
         end
@@ -91,9 +103,9 @@ module Typed
       return @schema.check!(key, self[key]) unless type
 
       self[key].must.struct(type) {
-        summary = self[key].inspect
-        summary = summary[0,200] + "..." if summary.size > 200
-        raise TypeError, "'#{key}' expects '#{type.inspect}', but got #{summary}"
+        got   = Must::StructInfo.new(self[key]).compact.inspect
+        value = self[key].inspect.truncate(200)
+        raise TypeError, "%s(%s) got %s: %s" % [key, type.inspect, got, value]
       }
     end
 

data/lib/typed/schema.rb

@@ -16,11 +16,12 @@ module Typed
     end
 
     def []=(key, val)
-      if exist?(key)
-        raise "%s is already typed as `%s'" % [key, @types[key].inspect]
-      else
-        @types[key] = val
-      end
+      # update schema if sub-class, otherwise raises
+      val.must.struct(@types[key]) {
+        raise TypeError, "%s is already typed as `%s'" % [key, @types[key].inspect]
+      } if exist?(key)
+
+      @types[key] = val
     end
 
     def check!(key, val)
@@ -32,7 +33,7 @@ module Typed
       else
         expected = @types[key].inspect
         got      = Must::StructInfo.new(val).compact.inspect
-        value    = val.inspect.size > 200 ? val.inspect[0,200] + "..." : val.inspect
+        value    = val.inspect.truncate(200)
         raise TypeError, "%s(%s) got %s: %s" % [key, expected, got, value]
       end
     end

data/lib/typed/version.rb

@@ -1,3 +1,3 @@
 module Typed
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/hash_spec.rb

@@ -43,23 +43,7 @@ describe Typed::Hash do
 
     it "should check schema if exists" do
       data[:foo] = String
-
-      lambda {
-        data[:foo] = "foo"
-      }.should_not raise_error(TypeError)
-
-      lambda {
-        data[:foo] = 1
-      }.should raise_error(TypeError)
-    end
-
-    it "should check schema if exists" do
-      data[:foo] = String
-
-      lambda {
-        data[:foo] = "foo"
-      }.should_not raise_error(TypeError)
-
+      data[:foo] = "foo"
       lambda {
         data[:foo] = 1
       }.should raise_error(TypeError)
@@ -77,6 +61,47 @@ describe Typed::Hash do
       data[:foo] = 2
       data[:foo].should == 2
     end
+
+    it "cannot override existing value when type mismatch" do
+      data[:foo] = 1            # Fixnum
+      lambda {
+        data[:foo] = 0.5        # Float
+      }.should raise_error(TypeError)
+    end
+
+    it "can override existing value if declared by common ancestor" do
+      data[:foo] = Numeric
+      data[:foo] = 1
+      data[:foo] = 0.5
+      data[:foo].should == 0.5
+    end
+
+    it "should raise TypeError when schema given twice" do
+      data[:foo] = String
+      lambda {
+        data[:foo] = Integer
+      }.should raise_error(TypeError)
+    end
+
+    it "can ovreride schema when given schema is sub-class of existing one" do
+      data[:num] = Numeric
+      data[:num] = 10
+      data.schema(:num).should == Numeric
+      data[:num] = Fixnum
+      data.schema(:num).should == Fixnum
+      data[:num] = 20
+      data.schema(:num).should == Fixnum
+    end
+  end
+
+  ######################################################################
+  ### Reflection
+
+  describe "#schema(key)" do
+    it "should return its schema(type class)" do
+      data[:num] = 1
+      data.schema(:num).should == Fixnum
+    end
   end
 
   ######################################################################

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: typed
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - maiha