typed 0.1.5 → 0.2.0

data/README.rdoc

@@ -65,7 +65,7 @@ We need some typed variables to avoid silly and stealth mistakes.
   => [] 
   >> vars[:a] = 1
   >> vars.changes.keys
-  => [:a] 
+  => ["a"] 
   >> vars.changes.reset
   >> vars.changes.keys
   => [] 
@@ -92,6 +92,7 @@ We need some typed variables to avoid silly and stealth mistakes.
 
 * Typed::Hash can't assign Class/Module cause they are treated as type definitions
 * must gem adds Object#must method
+* All keys are forced to String [since: verson 0.2.0]
 
 
 == INSTALL:

data/lib/typed/changes.rb

@@ -9,7 +9,7 @@ module Typed
     end
 
     def touch(key)
-      @hash[key] = Time.now
+      @hash[key.to_s] = Time.now
     end
 
     def keys

data/lib/typed/default.rb

@@ -5,14 +5,14 @@ module Typed
     end
 
     def []=(key, val)
-      return if @kvs.exist?(key)
-      @kvs[key] = val
+      return if @kvs.exist?(key.to_s)
+      @kvs[key.to_s] = val
     end
 
     def regsiter_lazy(key, block)
-      return if @kvs.exist?(key)
+      return if @kvs.exist?(key.to_s)
       raise ArgumentError, "Lazy default value needs block: #{key}" unless block
-      @kvs[key] = Schema::LazyValue.new(block)
+      @kvs[key.to_s] = Schema::LazyValue.new(block)
     end
   end
 end

data/lib/typed/hash.rb

@@ -47,7 +47,7 @@ module Typed
     def [](key)
       if exist?(key)
         val = load(key)
-        @events.fire(:read, key, val)
+        @events.fire(:read, key.to_s, val)
         return val
       else
         from = caller.is_a?(Array) ? caller.first : self.class
@@ -56,8 +56,8 @@ module Typed
     end
 
     def update(key, val)
-      @hash[key] = val
-      @events.fire(:write, key, val)
+      @hash[key.to_s] = val
+      @events.fire(:write, key.to_s, val)
       @changes.touch(key)
     end
 
@@ -87,7 +87,7 @@ module Typed
     ### Testing
 
     def exist?(key)
-      @hash.has_key?(key)
+      @hash.has_key?(key.to_s)
     end
 
     def set?(key)
@@ -96,7 +96,7 @@ module Typed
 
     def check(key, type = nil)
       type ||= @schema[key]
-      @schema.validate!(key, @hash[key], type)
+      @schema.validate!(key, @hash[key.to_s], type)
     end
 
     ######################################################################
@@ -117,13 +117,13 @@ module Typed
     ### Utils
 
     def inspect
-      keys = @hash.keys.map(&:to_s).sort.join(',')
+      keys = @hash.keys.sort.join(',')
       "{#{keys}}"
     end
 
     private
       def load(key)
-        value = @hash[key]
+        value = @hash[key.to_s]
 
         # LazyValue should be evaluated at runtime
         return (self[key] = value.value.call) if value.is_a?(Schema::LazyValue)

data/lib/typed/schema.rb

@@ -38,34 +38,34 @@ module Typed
     end
 
     def definition(key)
-      @types[key]
+      @types[key.to_s]
     end
 
     def [](key)
-      @types[key].value
+      @types[key.to_s].value
     end
 
     def declare!(key, declare)
       case declare.must.be.kind_of(Explicit, Implicit)
       when Explicit
-        case @types[key]
+        case @types[key.to_s]
         when Explicit
-          raise TypeError, "%s has already been declared as `%s'" % [key, @types[key].value.inspect]
+          raise TypeError, "%s has already been declared as `%s'" % [key, @types[key.to_s].value.inspect]
         when Implicit
           # update schema if sub-class, otherwise raises
-          declare.value.must.struct?(@types[key].value) or
-            raise TypeError, "%s has already been typed as `%s'" % [key, @types[key].value.inspect]
+          declare.value.must.struct?(@types[key.to_s].value) or
+            raise TypeError, "%s has already been typed as `%s'" % [key, @types[key.to_s].value.inspect]
         end
         explicit(key, declare)
 
       when Implicit
-        case @types[key]
+        case @types[key.to_s]
         when Explicit
           # nop
         when Implicit
           # update schema if sub-struct
           struct = self.class.struct(declare.value)
-          if struct.must.struct?(@types[key].value)
+          if struct.must.struct?(@types[key.to_s].value)
             implicit(key, struct)
           end
         else          
@@ -91,12 +91,12 @@ module Typed
     private
       def implicit(key, val)
         val = Implicit.new(val) unless val.is_a?(Implicit)
-        @types[key] = val
+        @types[key.to_s] = val
       end
 
       def explicit(key, val)
         val = Explicit.new(val) unless val.is_a?(Explicit)
-        @types[key] = val
+        @types[key.to_s] = val
       end
   end
 end

data/lib/typed/version.rb

@@ -1,3 +1,3 @@
 module Typed
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/spec/changes_spec.rb

@@ -8,25 +8,25 @@ describe Typed::Changes do
 
     it "should return [:a] after touch(:a)" do
       subject.touch(:a)
-      subject.keys.should == [:a]
+      subject.keys.should == ["a"]
     end
 
     it "should return [:a,:b] after touch(:a) and touch(:b)" do
       subject.touch(:a)
       subject.touch(:b)
-      subject.keys.should == [:a, :b]
+      subject.keys.should == ["a", "b"]
     end
 
     it "should return [:b,:a] after touch(:b) and touch(:a)" do
       subject.touch(:b)
       subject.touch(:a)
-      subject.keys.should == [:b, :a]
+      subject.keys.should == ["b", "a"]
     end
 
     it "should return [:a] after touch(:a) twice" do
       subject.touch(:a)
       subject.touch(:a)
-      subject.keys.should == [:a]
+      subject.keys.should == ["a"]
     end
 
     it "should return [] after touch(:a) and reset" do

data/spec/events_spec.rb

@@ -13,7 +13,7 @@ describe Typed::Events do
 
     data[:a]
 
-    read.should == [[:a,1]]
+    read.should == [["a",1]]
   end
 
   it "should observe :write event" do
@@ -28,7 +28,7 @@ describe Typed::Events do
 
     data[:a] = 3
     data[:c] = 5
-    written.should == [[:a,3], [:c,5]]
+    written.should == [["a",3], ["c",5]]
   end
 
   it "should not fire :read event on :write" do

data/spec/hash_spec.rb

@@ -22,17 +22,24 @@ describe Typed::Hash do
     data.values.sort.should == [1, 2]
   end
 
-  describe "#[]" do
-    it "should return value if exists" do
-      data[:foo] = 1
-      data[:foo].should == 1
-    end
+  it "should stringify keys" do
+    data["a"] = 1
+    data[:a].should == 1
+    data[:a] = 2
+    data["a"].should == 2
+  end
 
+  describe "#[]" do
     it "should raise NotDefined if value not exists" do
       lambda {
-        data[:foo]
+        data["foo"]
       }.should raise_error(Typed::NotDefined)
     end
+
+    it "should return value if exists" do
+      data["foo"] = 1
+      data["foo"].should == 1
+    end
   end
 
   describe "#[]=" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: typed
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 5
-  version: 0.1.5
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-01 00:00:00 +09:00
+date: 2012-05-02 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency