typed 0.1.1 → 0.1.2

data/Gemfile

@@ -1,4 +1,4 @@
 source "http://rubygems.org"
 
 gem 'activesupport'
-gem 'must', '>= 0.2.5'
+gem 'must', '>= 0.2.6'

data/lib/typed.rb

@@ -5,7 +5,6 @@ require "typed/hash"
 
 module Typed
   NotDefined = Class.new(RuntimeError)
-  LazyValue  = Struct.new(:block)
 
   autoload :Default, "typed/default"
   autoload :Schema , "typed/schema"

data/lib/typed/default.rb

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

data/lib/typed/hash.rb

@@ -11,7 +11,7 @@ module Typed
     def initialize(options = {})
       @hash    = {}
       @options = DEFAULT_OPTIONS.merge(options.must(::Hash))
-      @schema  = Schema.new(self)
+      @schema  = Schema.new
       @default = Default.new(self)
     end
 
@@ -54,38 +54,25 @@ module Typed
     end
 
     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
-            # not schema
-          when [], {}
-            # ambiguous
-            @schema[key] = val
-          when nil, true, false
-            # no information
-          else
-            struct = Must::StructInfo.new(val).compact
-            @schema[key] = struct
-            # when schema format, just declare schema and return
-            return if struct == val
-          end
-        end
+      declare = @schema.declare_method(val)
+      case declare
+      when Schema::LazyValue
+        # not schema
+        update(key, val)
+      when Schema::Ambiguous
+        # TODO: How to treat these classes
+        update(key, val)
+        check(key)
+      when Schema::Explicit
+        @schema.declare!(key, declare)
+        check(key) if exist?(key)
+      when Schema::Implicit
+        @schema.declare!(key, declare)
+        update(key, val)
+        check(key)
+      else
+        raise NotImplementedError, "[BUG] no assignment logic for: #{declare.class}"
       end
-      update(key, val)
     end
 
     ######################################################################
@@ -100,13 +87,8 @@ module Typed
     end
 
     def check(key, type = nil)
-      return @schema.check!(key, self[key]) unless type
-
-      self[key].must.struct(type) {
-        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]
-      }
+      type ||= @schema[key]
+      @schema.validate!(key, self[key], type)
     end
 
     ######################################################################
@@ -133,12 +115,11 @@ module Typed
 
     private
       def load(key)
-        # LazyValue should be evaluated at runtime
         value = @hash[key]
-        if value.is_a?(LazyValue)
-          value = value.block.call 
-          self[key] = value
-        end
+
+        # LazyValue should be evaluated at runtime
+        return (self[key] = value.value.call) if value.is_a?(Schema::LazyValue)
+
         return value
       end
 

data/lib/typed/schema.rb

@@ -1,41 +1,102 @@
 module Typed
   class Schema
     NotFound = Class.new(RuntimeError)
+    Declared = Struct.new(:value)
+    class Ambiguous < Declared; end
+    class Implicit  < Declared; end
+    class Explicit  < Declared; end
+    class Nothing   < Declared; end
+    class LazyValue < Declared; end
 
-    def initialize(kvs)
-      @kvs = kvs
-      @types = {}
+    def self.schema?(obj)
+      return true  if obj.is_a?(Class) or obj.is_a?(Module)
+      return false if obj == [] or obj == {}
+      return schema?(obj.first) if obj.is_a?(Array)
+      return obj.first.any?{|i| schema?(i)} if obj.is_a?(::Hash)
+      return false
     end
 
-    def exist?(key)
-      @types.has_key?(key)
+    def self.struct(obj)
+      struct = Must::StructInfo.new(obj).compact
+      struct = Array  if struct == []
+      struct = ::Hash if struct == {}
+      return struct
     end
 
-    def [](key)
+    def self.declare_method(val)
+      case val
+      when LazyValue; val
+      when true,false,nil; Ambiguous.new(val)
+      else; schema?(val) ? Explicit.new(val) : Implicit.new(val)
+      end
+    end
+
+    delegate :schema?, :declare_method, :to => "self.class"
+
+    def initialize
+      @types = ::Hash.new{ Nothing.new }
+    end
+
+    def definition(key)
       @types[key]
     end
 
-    def []=(key, val)
-      # 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)
+    def [](key)
+      @types[key].value
+    end
+
+    def declare!(key, declare)
+      case declare.must.be.kind_of(Explicit, Implicit)
+      when Explicit
+        case @types[key]
+        when Explicit
+          raise TypeError, "%s has already been declared as `%s'" % [key, @types[key].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]
+        end
+        explicit(key, declare)
 
-      @types[key] = val
+      when Implicit
+        case @types[key]
+        when Explicit
+          # nop
+        when Implicit
+          # update schema if sub-struct
+          struct = self.class.struct(declare.value)
+          if struct.must.struct?(@types[key].value)
+            implicit(key, struct)
+          end
+        else          
+          implicit(key, self.class.struct(declare.value))
+        end
+      end
     end
 
-    def check!(key, val)
-      struct = @types[key] or
-        raise Schema::NotFound, key.to_s
+    def validate!(key, val, klass)
+      return true unless klass
+#      raise Schema::NotFound, key.to_s unless klass
 
-      if val.must.struct?(struct)
+      if val.must.struct?(klass)
         return true 
       else
-        expected = @types[key].inspect
+        expected = klass.inspect
         got      = Must::StructInfo.new(val).compact.inspect
         value    = val.inspect.truncate(200)
         raise TypeError, "%s(%s) got %s: %s" % [key, expected, got, value]
       end
     end
+
+    private
+      def implicit(key, val)
+        val = Implicit.new(val) unless val.is_a?(Implicit)
+        @types[key] = val
+      end
+
+      def explicit(key, val)
+        val = Explicit.new(val) unless val.is_a?(Explicit)
+        @types[key] = val
+      end
   end
 end

data/lib/typed/version.rb

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

data/spec/hash_spec.rb

@@ -36,9 +36,12 @@ describe Typed::Hash do
   end
 
   describe "#[]=" do
-    it "should set not data but schema when schema given" do
+    it "should accept as schema when class is given" do
       data[:foo] = String
       data.exist?(:foo).should == false
+
+      data[:bar] = Hash
+      data.exist?(:bar).should == false
     end
 
     it "should check schema if exists" do
@@ -49,11 +52,29 @@ describe Typed::Hash do
       }.should raise_error(TypeError)
     end
 
-    it "should guess and check schema if not exists" do
+    it "should implicitly declare schema when assigned" do
       data[:foo] = 1
-      lambda {
-        data[:foo] = "test"
-      }.should raise_error(TypeError)
+      data.schema(:foo).should == Fixnum
+
+      data[:bar] = {:a => 1}
+      data.schema(:bar).should == {Symbol => Fixnum}
+    end
+
+    it "should implicitly declare schema if not exists" do
+      data[:foo] = 1
+      data.schema(:foo).should == Fixnum
+    end
+
+    # TODO: How can we declare Boolean? How to treat nil?
+    it "should not implicitly declare schema when nil,true,false" do
+      data[:foo] = nil
+      data.schema(:foo).should == nil
+
+      data[:bar] = true
+      data.schema(:bar).should == nil
+
+      data[:baz] = false
+      data.schema(:baz).should == nil
     end
 
     it "can override existing value if same type" do
@@ -76,21 +97,67 @@ describe Typed::Hash do
       data[:foo].should == 0.5
     end
 
-    it "should raise TypeError when schema given twice" do
-      data[:foo] = String
+    it "should create new objects for Array,Hash is given for schema" do
+      data[:a] = []
+      data[:a][0] = 1
+      data.schema(:a).should == Array
+
+      data[:h] = {}
+      data[:h]["x"] = 1
+      data.schema(:h).should == Hash
+    end
+
+    it "should check existing value when explicit declarement is given" do
+      data[:foo] = {}
+      data[:foo][:a] = 1
       lambda {
-        data[:foo] = Integer
+        data[:foo] = {String => Integer}
       }.should raise_error(TypeError)
     end
 
-    it "can ovreride schema when given schema is sub-class of existing one" do
+    it "cannot ovreride explicit declarement" 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
+      lambda {
+        data[:num] = Fixnum
+      }.should raise_error(TypeError)
+    end
+
+    it "can override implicitly declared schema by sub-struct schema" do
+      data[:foo] = {}
+      data[:foo].should == {}
+      data.schema(:foo).should == Hash
+
+      data[:foo] = {String => Integer}
+      data[:foo].should == {}
+      data.schema(:foo).should == {String => Integer}
+    end
+
+    it "should implicitly override schema when given schema is sub-struct of existing one" do
+      data[:foo] = {}
+      data[:foo].should == {}
+      data.schema(:foo).should == Hash
+
+      data[:foo] = {:a => 1}
+      data[:foo].should == {:a => 1}
+      data.schema(:foo).should == {Symbol => Fixnum}
+    end
+
+    it "should not override schema if explicitly declarement exists" do
+      data[:foo] = Hash
+      data[:foo] = {}
+      data.schema(:foo).should == Hash
+
+      data[:foo] = {:a => 1}
+      data[:foo].should == {:a => 1}
+      data.schema(:foo).should == Hash
+    end
+
+    it "raise TypeError when re-declarement causes type mismatch" do
+      data[:foo] = Numeric
+      data[:foo] = 0.5
+      lambda {
+        data[:foo] = Fixnum
+      }.should raise_error(TypeError)
     end
   end
 

data/spec/schema_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Typed::Schema do
+  describe ".schema?" do
+    delegate :schema?, :to => "Typed::Schema"
+
+    it "should return true for Class,Module" do
+      schema?(Class ).should == true
+      schema?(Module).should == true
+      schema?(Array ).should == true
+      schema?(Hash  ).should == true
+      schema?(Fixnum).should == true
+    end
+
+    it "should return false for [],{}" do
+      schema?([]).should == false
+      schema?({}).should == false
+    end
+
+    it "should return true for [Class,Module,...]" do
+      schema?([Array ]).should == true
+      schema?([Hash  ]).should == true
+      schema?([Object]).should == true
+    end
+
+    it "should return true for {(Class,Module) => (Class,Module)}" do
+      schema?({String => Fixnum}).should == true
+      schema?({Hash   => Array }).should == true
+    end
+
+    it "should return false for instances" do
+      schema?(1).should == false
+      schema?([1]).should == false
+      schema?({:a => 2}).should == false
+    end
+  end
+end

data/typed.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency "activesupport"
-  s.add_dependency "must", ">= 0.2.5"
+  s.add_dependency "must", ">= 0.2.6"
 
   s.add_development_dependency "rspec"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: typed
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-10 00:00:00 +09:00
+date: 2012-02-13 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,12 +40,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 29
+        hash: 27
         segments: 
         - 0
         - 2
-        - 5
-        version: 0.2.5
+        - 6
+        version: 0.2.6
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -82,6 +82,7 @@ files:
 - lib/typed/schema.rb
 - lib/typed/version.rb
 - spec/hash_spec.rb
+- spec/schema_spec.rb
 - spec/spec_helper.rb
 - typed.gemspec
 has_rdoc: true