typed 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,71 @@
+= typed
+
+  A Ruby library for Typed variables
+
+
+== DESCRIPTION:
+
+  No more "NoMethodError: undefined method"!
+  We need some typed variables to avoid silly and stealth mistakes.
+
+
+== SYNOPSIS:
+
+  >> vars = Typed::Hash.new
+  => {}
+
+  # Class/Module means not values but type definitions
+  >> vars[:num] = Numeric
+  >> vars[:num] = 10
+  => 10
+  >> vars[:num] = "a"
+  TypeError: num(Numeric) got String: "a"
+
+  # Types are automatically guessed
+  >> vars[:foo] = 10
+  => 10
+  >> vars[:foo] = "a"
+  TypeError: foo(Fixnum) got String: "a"
+
+  # Referrence without assigned raises error
+  >> vars[:xxx]
+  Typed::NotDefined: 'xxx' is not initialized
+
+  # Hash/Array can be used for complex schema.
+  >> vars[:services] = {Integer => [{Symbol => String}]}
+  >> vars[:services] = {
+       21 => [{:tcp => "ftp"}, {:udp => "fsp"}],
+       25 => [{:tcp => "smtp"}],
+     }
+  => {25=>[{:tcp=>"smtp"}], 21=>[{:tcp=>"ftp"}, {:udp=>"fsp"}]}
+  >> vars[:services] = {22 => {:tcp => "ssh"}}
+  TypeError: services({Integer=>[{Symbol=>String}]}) got {Fixnum=>{Symbol=>String}}: {22=>{:tcp=>"ssh"}}
+
+
+== REQUIREMENTS:
+
+* activesupport gem
+* must gem
+
+
+== CAUTIONS:
+
+* Typed::Hash can't assign Class/Module cause they are treated as type definitions
+* must gem adds Object#must method
+
+
+== INSTALL:
+
+  sudo gem install typed
+
+
+== DOCUMENT:
+
+* http://github.com/maiha/typed
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 maiha@wota.jp

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/typed.rb

@@ -0,0 +1,13 @@
+require "must"
+require "active_support/core_ext"
+require "typed/version"
+require "typed/hash"
+
+module Typed
+  NotDefined = Class.new(RuntimeError)
+  LazyValue  = Struct.new(:block)
+
+  autoload :Default, "typed/default"
+  autoload :Schema , "typed/schema"
+end
+

data/lib/typed/default.rb

@@ -0,0 +1,18 @@
+module Typed
+  class Default
+    def initialize(kvs)
+      @kvs = kvs
+    end
+
+    def []=(key, val)
+      return if @kvs.exist?(key)
+      @kvs[key] = val
+    end
+
+    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)
+    end
+  end
+end

data/lib/typed/hash.rb

@@ -0,0 +1,137 @@
+module Typed
+  class Hash
+    include Enumerable
+
+    DEFAULT_OPTIONS = {
+      :schema => true,
+    }
+
+    delegate :keys, :to=>"@hash"
+
+    def initialize(options = {})
+      @hash    = {}
+      @options = DEFAULT_OPTIONS.merge(options.must(::Hash))
+      @schema  = Schema.new(self)
+      @default = Default.new(self)
+    end
+
+    ######################################################################
+    ### Default values
+
+    def default(key = nil, &block)
+      if key
+        @default.regsiter_lazy(key, block)
+      else
+        @default
+      end
+    end
+
+    ######################################################################
+    ### Schema values
+
+    def schema(key = nil)
+      if key
+        @schema[key]
+      else
+        @schema
+      end
+    end
+
+    ######################################################################
+    ### Accessor
+
+    def [](key)
+      if exist?(key)
+        return load(key)
+      else
+        from = caller.is_a?(Array) ? caller.first : self.class
+        raise NotDefined, "'#{key}' is not initialized\n#{from}"
+      end
+    end
+
+    def update(key, val)
+      @hash[key] = val
+    end
+
+    def []=(key, val)
+      if check_schema?(key)
+        if @schema.exist?(key)
+          @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
+            return if struct == val
+          end
+        end
+      end
+      update(key, val)
+    end
+
+    ######################################################################
+    ### Testing
+
+    def exist?(key)
+      @hash.has_key?(key)
+    end
+
+    def set?(key)
+      !! (exist?(key) && self[key])
+    end
+
+    def check(key, type = nil)
+      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}"
+      }
+    end
+
+    ######################################################################
+    ### Hash compat
+
+    def each(&block)
+      keys.each do |key|
+        val = self[key]
+        block.call([key,val])
+      end
+    end
+
+    def values
+      keys.map{|key| self[key]}
+    end
+
+    ######################################################################
+    ### Utils
+
+    def inspect
+      keys = @hash.keys.map(&:to_s).sort.join(',')
+      "{#{keys}}"
+    end
+
+    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
+        return value
+      end
+
+      def check_schema?(key)
+        true
+      end
+  end
+end

data/lib/typed/schema.rb

@@ -0,0 +1,40 @@
+module Typed
+  class Schema
+    NotFound = Class.new(RuntimeError)
+
+    def initialize(kvs)
+      @kvs = kvs
+      @types = {}
+    end
+
+    def exist?(key)
+      @types.has_key?(key)
+    end
+
+    def [](key)
+      @types[key]
+    end
+
+    def []=(key, val)
+      if exist?(key)
+        raise "%s is already typed as `%s'" % [key, @types[key].inspect]
+      else
+        @types[key] = val
+      end
+    end
+
+    def check!(key, val)
+      struct = @types[key] or
+        raise Schema::NotFound, key.to_s
+
+      if val.must.struct?(struct)
+        return true 
+      else
+        expected = @types[key].inspect
+        got      = Must::StructInfo.new(val).compact.inspect
+        value    = val.inspect.size > 200 ? val.inspect[0,200] + "..." : val.inspect
+        raise TypeError, "%s(%s) got %s: %s" % [key, expected, got, value]
+      end
+    end
+  end
+end

data/lib/typed/version.rb

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

data/spec/hash_spec.rb

@@ -0,0 +1,181 @@
+require "spec_helper"
+
+describe Typed::Hash do
+  def data
+    subject
+  end
+
+  ######################################################################
+  ### Accessor
+
+  it "should behave like hash" do
+    data["a"] = 1
+    data["b"] = 2
+    data.keys.sort.should == ["a", "b"]
+    data.values.sort.should == [1, 2]
+  end
+
+  it "should behave like hash with lazy values" do
+    data["a"] = 1
+    data.default("b") { 2 }
+    data.keys.sort.should == ["a", "b"]
+    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 raise NotDefined if value not exists" do
+      lambda {
+        data[:foo]
+      }.should raise_error(Typed::NotDefined)
+    end
+  end
+
+  describe "#[]=" do
+    it "should set not data but schema when schema given" do
+      data[:foo] = String
+      data.exist?(:foo).should == false
+    end
+
+    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)
+
+      lambda {
+        data[:foo] = 1
+      }.should raise_error(TypeError)
+    end
+
+    it "should guess and check schema if not exists" do
+      data[:foo] = 1
+      lambda {
+        data[:foo] = "test"
+      }.should raise_error(TypeError)
+    end
+
+    it "can override existing value if same type" do
+      data[:foo] = 1
+      data[:foo] = 2
+      data[:foo].should == 2
+    end
+  end
+
+  ######################################################################
+  ### Testing
+
+  describe "#exist?" do
+    it "should return true if the value is set" do
+      data[:foo] = 1
+      data.exist?(:foo).should == true
+    end
+
+    it "should return false if the value is not set" do
+      data.exist?(:foo).should == false
+    end
+  end
+
+  describe "#set?" do
+    it "should return true if the value is set and not (nil|false)" do
+      data[:foo] = 0
+      data.set?(:foo).should == true
+
+      data.default[:bar] = 0
+      data.set?(:bar).should == true
+
+      data.default(:baz) { 0 }
+      data.set?(:baz).should == true
+    end
+
+    it "should return false if the value is set but (nil|false)" do
+      data[:foo] = nil
+      data.set?(:foo).should == false
+
+      data[:foo] = false
+      data.set?(:foo).should == false
+    end
+  end
+
+  describe "#check" do
+    it "should satisfy its type" do
+      data[:foo] = 1
+      lambda {
+        data.check(:foo, Integer)
+      }.should_not raise_error
+    end
+
+    it "should satisfy its struct" do
+      data[:foo] = {:a => "text"}
+      lambda {
+        data.check(:foo, {Symbol => String})
+      }.should_not raise_error
+    end
+
+    it "should raise TypeError if not satisfied" do
+      data[:foo] = {:a => "text"}
+      lambda {
+        data.check(:foo, Integer)
+      }.should raise_error(TypeError)
+    end
+  end
+
+  ######################################################################
+  ### Default values
+
+  describe "#default" do
+    it "should set default value" do
+      data.default[:foo] = 1
+      data.exist?(:foo).should == true
+      data[:foo].should == 1
+    end
+
+    it "should be overriden by []=" do
+      data.default[:foo] = 1
+      data[:foo] = 2
+      data[:foo].should == 2
+    end
+
+    it "should not affect data when already set" do
+      data[:foo] = 1
+      data.default[:foo] = 2
+      data[:foo].should == 1
+    end
+  end
+
+  describe "#default(&block)" do
+    it "should set lazy default value" do
+      @a = 1
+      data.default(:foo) { @a }
+      @a = 2
+      data[:foo].should == 2
+    end
+
+    it "should freeze lazy default value once accessed" do
+      @a = 1
+      data.default(:foo) { @a }
+      @a = 2
+      data[:foo].should == 2
+      @a = 3
+      data[:foo].should == 2
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'typed'
+

data/typed.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "typed/version"
+
+Gem::Specification.new do |s|
+  s.name        = "typed"
+  s.version     = Typed::VERSION
+  s.authors     = ["maiha"]
+  s.email       = ["maiha@wota.jp"]
+  s.homepage    = "https://github.com/maiha/typed"
+  s.summary     = %q{A Ruby library for Typed variables}
+  s.description = %q{Typed::Hash}
+
+  s.rubyforge_project = "typed"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport"
+  s.add_dependency "must", ">= 0.2.5"
+
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: typed
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- maiha
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-10 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: must
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 2
+        - 5
+        version: 0.2.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Typed::Hash
+email: 
+- maiha@wota.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/typed.rb
+- lib/typed/default.rb
+- lib/typed/hash.rb
+- lib/typed/schema.rb
+- lib/typed/version.rb
+- spec/hash_spec.rb
+- spec/spec_helper.rb
+- typed.gemspec
+has_rdoc: true
+homepage: https://github.com/maiha/typed
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: typed
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby library for Typed variables
+test_files: []
+