typed 0.2.7 → 0.2.8

data/lib/typed/hash.rb

@@ -6,12 +6,12 @@ module Typed
       :schema => true,
     }
 
-    delegate :keys, :to=>"@hash"
+    delegate :keys, :size, :to=>"@hash"
     attr_reader :changes
     attr_reader :events
 
     def initialize(options = {})
-      @hash    = {}
+      @hash    = ActiveSupport::OrderedHash.new
       @options = DEFAULT_OPTIONS.merge(options.must(::Hash))
       @schema  = Schema.new
       @default = Default.new(self)
@@ -102,6 +102,13 @@ module Typed
     ######################################################################
     ### Hash compat
 
+    def each_pair(&block)
+      keys.each do |key|
+        val = self[key]
+        block.call(key,val)
+      end
+    end
+
     def each(&block)
       keys.each do |key|
         val = self[key]
@@ -109,6 +116,14 @@ module Typed
       end
     end
 
+    def each_key(&block)
+      keys.each(&block)
+    end
+
+    def each_value(&block)
+      each_pair{|k,v| block.call(v)}
+    end
+
     def values
       keys.map{|key| self[key]}
     end

data/lib/typed/scala.rb

@@ -1,114 +1,12 @@
 module Typed
   module Scala
+    autoload :Accessors, "typed/scala/accessors"
+    autoload :Variables, "typed/scala/variables"
+    autoload :Parser   , "typed/scala/parser"
+    autoload :Builder  , "typed/scala/builder"
+    autoload :Reflect  , "typed/scala/reflect"
 
-    ######################################################################
-    ### instance methods
-
-    def attrs
-      @attrs ||= Typed::Scala::Variables.build_attrs(self.class)
-    end
-
-    def [](key)
-      if attrs.schema.exist?(key)
-        attrs[key.to_s]
-      else
-        raise Typed::NotDefined, "#{key} is not a member of #{self.class}"
-      end
-    end
-
-    def []=(key, val)
-      if attrs.schema.exist?(key)
-        if self.class.vals[key.to_s] and attrs.exist?(key)
-          raise Typed::FixedValue, "reassignment to #{key}"
-        end
-        attrs[key.to_s] = val
-      else
-        raise Typed::NotDefined, "#{key} is not a member of #{self.class}"
-      end
-    end
-
-    ######################################################################
-    ### provided api
-
-    module Val
-      def vals
-        @typed_scala_vals ||= Typed::Scala::Variables.build_variables(self, :val)
-      end
-
-      def val(obj)
-        Typed::Scala::Variables.apply(self, :val, caller[0], obj)
-      end
-    end
-
-    module Var
-      def vars
-        @typed_scala_vars ||= Typed::Scala::Variables.build_variables(self, :var)
-      end
-
-      def var(obj)
-        Typed::Scala::Variables.apply(self, :var, caller[0], obj)
-      end
-    end
-
-    ######################################################################
-    ### class schema
-
-    module Variables
-      ParseError = Class.new(SyntaxError)
-
-      def self.apply(klass, type, caller, obj)
-        name = parse(klass, type, caller)
-        define(klass, type, name, obj)
-      end
-
-      def self.define(klass, type, name, obj)
-        vars = klass.__send__("#{type}s")
-        vars[name] = obj
-        
-        klass.class_eval do
-          define_method(name) { self[name.to_s] }
-          define_method("#{name}=") {|v| self[name.to_s] = v }
-        end
-      end
-
-      def self.parse(klass, type, caller)
-        # "/tmp/adsvr/dsl.rb:23"
-        case caller
-        when %r{^(.*?):(\d+)}o
-          file   = $1
-          lineno = $2.to_i
-
-          lines = (@lines ||= {})[klass] ||= File.readlines(file)
-          case lines[lineno-1].to_s
-          when /^\s*#{type}\s+(\S+)\s+=/
-            return $1
-          else
-            raise ParseError, "#{self} from #{caller}"
-          end
-        else
-          raise ParseError, "#{self} from caller:#{caller}"
-        end
-      end
-
-      def self.build_attrs(klass)
-        attrs = Typed::Hash.new
-        klass.vals.each_pair{|name, obj| attrs[name] = obj}
-        klass.vars.each_pair{|name, obj| attrs[name] = obj}
-        return attrs
-      end
-
-      def self.build_variables(klass, type)
-        variables = ActiveSupport::OrderedHash.new
-
-        klass.ancestors[1 .. -1].select{|k| k < Typed::Scala}.reverse.each do |k|
-          k.instance_eval("[@typed_scala_#{type}s].compact").each do |hash|
-            variables.merge!(hash)
-          end
-        end
-
-        return variables
-      end
-    end
+    include Accessors
 
     ######################################################################
     ### module
@@ -116,8 +14,9 @@ module Typed
     def self.included(klass)
       super
 
-      klass.extend Scala::Val
-      klass.extend Scala::Var
+      klass.extend Scala::Reflect
+      klass.extend Scala::Parser
+      klass.extend Scala::Builder
     end
   end
 end

data/lib/typed/scala/accessors.rb

@@ -0,0 +1,37 @@
+module Typed
+  module Scala
+    ######################################################################
+    ### instance methods
+
+    module Accessors
+      include Enumerable
+
+      def each(&block)
+        __attrs__.each_pair(&block)
+      end
+
+      def __attrs__
+        @__attrs__ ||= Typed::Scala::Variables.build_attrs(self.class)
+      end
+
+      def [](key)
+        if __attrs__.schema.exist?(key)
+          __attrs__[key.to_s]
+        else
+          raise Typed::NotDefined, "#{key} is not a member of #{self.class}"
+        end
+      end
+
+      def []=(key, val)
+        if __attrs__.schema.exist?(key)
+          if self.class.vals[key.to_s] and __attrs__.exist?(key)
+            raise Typed::FixedValue, "reassignment to #{key}"
+          end
+          __attrs__[key.to_s] = val
+        else
+          raise Typed::NotDefined, "#{key} is not a member of #{self.class}"
+        end
+      end
+    end
+  end
+end

data/lib/typed/scala/builder.rb

@@ -0,0 +1,45 @@
+module Typed
+  module Scala
+
+    ######################################################################
+    ### Builder
+    module Builder
+      # Build instance from hash
+      def build(hash = {})
+        obj = new
+        hash.each_pair do |k,v|
+          obj[k] = v
+        end
+        return obj
+      end
+
+      # Build instance from array
+      def apply(*args)
+        if args.size > variables.size
+          raise "#{self}.apply expect #{variables.size} args, but got #{args.size}"
+        end
+
+        obj = new
+        variables.each_key do |name|
+          val = args.shift or next
+          obj[name] = val
+        end
+        return obj
+      end
+
+      # Build instance from array strictly. Raised when args size is differ.
+      def apply!(*args)
+        if args.size != variables.size
+          raise "#{self}.apply expect #{variables.size} args, but got #{args.size}"
+        end
+
+        obj = new
+        variables.each_key do |name|
+          obj[name] = args.shift
+        end
+        return obj
+      end
+    end
+
+  end
+end

data/lib/typed/scala/parser.rb

@@ -0,0 +1,26 @@
+module Typed
+  module Scala
+
+    ######################################################################
+    ### Parser
+    module Parser
+      # Modifiers
+      def override(*args)
+      end
+
+      def lazy(*args)
+      end
+
+      # Declarations
+      def val(obj)
+        Typed::Scala::Variables.apply(self, :val, caller[0], obj)
+      end
+
+      def var(obj)
+        Typed::Scala::Variables.apply(self, :var, caller[0], obj)
+        return :var
+      end
+    end
+
+  end
+end

data/lib/typed/scala/reflect.rb

@@ -0,0 +1,23 @@
+module Typed
+  module Scala
+
+    ######################################################################
+    ### Reflect
+
+    module Reflect
+      # variable synthesis
+      def variables
+        @variables ||= Typed::Scala::Variables.build(self)
+      end
+
+      def vals
+        @typed_scala_vals ||= Typed::Scala::Variables.build_variables(self, :val)
+      end
+
+      def vars
+        @typed_scala_vars ||= Typed::Scala::Variables.build_variables(self, :var)
+      end
+    end
+
+  end
+end

data/lib/typed/scala/variables.rb

@@ -0,0 +1,98 @@
+module Typed
+  module Scala
+    ######################################################################
+    ### class schema
+
+    module Variables
+      ParseError = Class.new(SyntaxError)
+
+      Declaration = Struct.new(:klass, :name, :type, :mods, :value)
+
+      def apply(klass, type, caller, obj)
+        dcl = parse(klass, type, caller)
+        dcl.value = obj
+
+        define_schema(dcl)
+        define_method(dcl)
+      end
+
+      def define_schema(dcl)
+        vars = dcl.klass.__send__("#{dcl.type}s")
+        vars[dcl.name] = dcl.value
+
+        # new feature
+        dcl.klass.variables[dcl.name] = dcl.value
+      end
+
+      def define_method(dcl)
+        name = dcl.name
+        dcl.klass.class_eval <<-STR, __FILE__, __LINE__ + 1
+          def #{name}
+            self['#{name}']
+          end
+
+          def #{name}=(v)
+            self['#{name}'] = v
+          end
+        STR
+      end
+
+      def parse(klass, type, caller)
+        # "/tmp/adsvr/dsl.rb:23"
+        case caller
+        when %r{^(.*?):(\d+)}o
+          file   = $1
+          lineno = $2.to_i
+
+          lines = (@lines ||= {})[klass] ||= File.readlines(file)
+          case lines[lineno-1].to_s
+          when /^\s*(override\s+)?(lazy\s+)?(val|var)\s+(\S+)\s+=/
+            mods = [$1, $2].compact.map(&:strip)
+            type = $3
+            name = $4
+            return Declaration.new(klass, name, type, mods)
+          else
+            raise ParseError, "#{self} from #{caller}"
+          end
+        else
+          raise ParseError, "#{self} from caller:#{caller}"
+        end
+      end
+
+      def build_attrs(klass)
+        attrs = Typed::Hash.new
+        klass.vals.each_pair{|name, obj| attrs[name] = obj}
+        klass.vars.each_pair{|name, obj| attrs[name] = obj}
+        return attrs
+      end
+
+      def build(klass)
+        variables = ActiveSupport::OrderedHash.new
+
+        klass.ancestors[1 .. -1].select{|k| k < Typed::Scala}.reverse.each do |k|
+          k.instance_eval("[@variables].compact").each do |hash|
+            variables.merge!(hash)
+          end
+        end
+
+        return variables
+      end
+
+      def build_variables(klass, type)
+#        variables = Typed::Hash.new
+        variables = ActiveSupport::OrderedHash.new
+
+        klass.ancestors[1 .. -1].select{|k| k < Typed::Scala}.reverse.each do |k|
+          k.instance_eval("[@typed_scala_#{type}s].compact").each do |hash|
+            variables.merge!(hash)
+          end
+        end
+
+        return variables
+      end
+
+      extend self
+    end
+
+  end
+end

data/lib/typed/version.rb

@@ -1,3 +1,3 @@
 module Typed
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

data/spec/hash_spec.rb

@@ -29,6 +29,13 @@ describe Typed::Hash do
     data["a"].should == 2
   end
 
+  describe "enumerable" do
+    it { should respond_to(:each) }
+    it { should respond_to(:each_pair) }
+    it { should respond_to(:each_key) }
+    it { should respond_to(:each_value) }
+  end
+
   describe "#[]" do
     it "should raise NotDefined if value not exists" do
       lambda {

data/spec/scala/attrs_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  include_context "scala_source"
+
+  ######################################################################
+  ### Column names
+
+  context "(attrs)" do
+    before { scala_source("A", <<-EOF)
+      class A
+        include Typed::Scala
+        val key   = String
+        var attrs = Hash
+      end
+      EOF
+    }
+
+    describe "#attrs, #attrs=" do
+      subject { A.new }
+
+      specify do
+        a = A.new
+        a.attrs = {:x=>1}
+        a.attrs.should == {:x=>1}
+      end
+    end
+
+    describe ".build" do
+      context "()" do
+        subject { A.build }
+        specify { lambda { subject.key   }.should raise_error(Typed::NotDefined) }
+        specify { lambda { subject.attrs }.should raise_error(Typed::NotDefined) }
+      end
+
+      context '(:key=>"x", :attrs=>{:a=>1})' do
+        subject { A.build(:key=>"x", :attrs=>{:a=>1}) }
+        its(:key)   { should == "x" }
+        its(:attrs) { should == {:a=>1} }
+      end
+    end
+  end
+end

data/spec/scala/build_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  include_context "scala_source"
+
+  ######################################################################
+  ### Basic usage
+
+  describe "User" do
+    before { scala_source("User", <<-EOF)
+      class User
+        include Typed::Scala
+
+        val key  = String
+        var name = String
+        var age  = Fixnum
+      end
+      EOF
+    }
+
+    subject { User }
+     
+    its(:vals) { should be_kind_of ActiveSupport::OrderedHash }
+    its(:vals) { should == { "key" => String } }
+    its(:vars) { should be_kind_of ActiveSupport::OrderedHash }
+    its(:vars) { should == { "name" => String, "age" => Fixnum } }
+
+    describe ".apply" do
+      specify "less args" do
+        user = User.apply("001", "aya")
+        user.key .should == "001"
+        user.name.should == "aya"
+        lambda { user.age}.should raise_error(Typed::NotDefined)
+      end
+
+      specify "exact args" do
+        user = User.apply("001", "aya", 12)
+        user.key .should == "001"
+        user.name.should == "aya"
+        user.age .should == 12
+      end
+
+      specify "more args" do
+        lambda { User.apply("001", "aya", 12, "!") }.should raise_error(/expect 3 args/)
+      end
+    end
+
+    describe ".apply!" do
+      specify "less args" do
+        lambda { User.apply!("001", "aya") }.should raise_error(/expect 3 args/)
+      end
+
+      specify "exact args" do
+        user = User.apply!("001", "aya", 12)
+        user.key .should == "001"
+        user.name.should == "aya"
+        user.age .should == 12
+      end
+
+      specify "more args" do
+          lambda { User.apply!("001", "aya", 12, "!") }.should raise_error(/expect 3 args/)
+      end
+    end
+
+    describe ".build" do
+      # "creates a new instance"
+      its(:build) { should be_kind_of User }
+
+      specify "ok" do
+        User.build.should be_kind_of(User)
+        User.build(:name=>"foo").name.should == "foo"
+
+        user = User.build(:key=>"x", :age=>12)
+        user.key.should == "x"
+        user.age.should == 12
+      end
+
+      specify "not member" do
+        lambda { User.build(:foo => "!") }.should raise_error(Typed::NotDefined)
+      end
+
+      specify "type error" do
+        lambda { User.build(:age => "!") }.should raise_error(TypeError)
+      end
+    end
+  end
+end

data/spec/scala/core_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  include_context "scala_source"
+
+  ######################################################################
+  ### Basic usage
+
+  describe "User" do
+    before { scala_source("User", <<-EOF)
+      class User
+        include Typed::Scala
+
+        val key  = String
+        var name = String
+        var age  = Fixnum
+      end
+      EOF
+    }
+     
+    let(:user) { User.new }
+    subject    { user}
+
+    describe ".variables" do
+      subject { User.variables }
+      its(:keys) { should == %w( key name age ) }
+      its(["key" ]) { should == String }
+      its(["name"]) { should == String }
+      its(["age" ]) { should == Fixnum }
+
+      specify "#each_pair" do
+        hash = {}
+        subject.each_pair do |name, type|
+          hash[name] = type
+        end
+        hash.should == {
+          "key"  => String,
+          "name" => String,
+          "age"  => Fixnum,
+        }
+      end
+    end
+
+    describe "attributes" do
+      it { should respond_to(:key) }
+      it { should respond_to(:name) }
+      it { should respond_to(:age) }
+      it { should respond_to(:[]) }
+      it { should respond_to(:[]=) }
+      it { should_not respond_to(:xxx) }
+    end
+
+    describe "#name=" do
+      specify "accept 'maiha'" do
+        (user.name = 'maiha').should == 'maiha'
+      end
+
+      specify "reject 100" do
+        lambda { user.name = 100 }.should raise_error(TypeError)
+      end
+    end
+
+    describe "enumerable" do
+      it { should respond_to(:each) }
+      it { should respond_to(:map) }
+    end
+
+    describe "#__attrs__" do
+      subject { User.apply!("001", "aya", 12).__attrs__ }
+
+      its(:size  ) { should == 3 }
+      its(:keys  ) { should == %w( key name age ) }
+      its(:values) { should == ["001", "aya", 12] }
+    end
+  end
+end

data/spec/scala/inherit_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  include_context "scala_source"
+
+  ######################################################################
+  ### Inheritance
+
+  context "(Point3D < Point2D)" do
+    before { scala_source("Point2D", <<-EOF)
+      class Point2D
+        include Typed::Scala
+        val x = Fixnum
+        val y = Fixnum
+      end
+      EOF
+    }
+     
+    before { scala_source("Point3D", <<-EOF)
+      class Point3D < Point2D
+        val z = Fixnum
+      end
+      EOF
+    }
+
+    context "Point2D" do
+      specify "contains x,y" do
+        Point2D.vals.keys.should == %w( x y )
+      end
+
+      describe "#x, #x=" do
+        specify "exist" do
+          p = Point2D.new
+          p.x = 1
+          p.x.should == 1
+          lambda { p.x = 2 }.should raise_error(Typed::FixedValue)
+        end
+      end
+
+      describe "#z" do
+        specify "not exist" do
+          p = Point2D.new
+          lambda { p["z"] = 3 }.should raise_error(Typed::NotDefined)
+          lambda { p.z = 3    }.should raise_error(NoMethodError)
+        end
+      end
+    end
+
+    context "Point3D" do
+      specify "contains x,y,z" do
+        Point3D.vals.keys.should == %w( x y z )
+      end
+
+      describe "#x, #x=, [x], [x]=" do
+        specify "exist" do
+          p = Point3D.new
+          p.x = 1
+          p.x.should == 1
+          p["x"].should == 1
+          lambda { p.x = 2    }.should raise_error(Typed::FixedValue)
+          lambda { p["x"] = 2 }.should raise_error(Typed::FixedValue)
+        end
+      end
+
+      describe "#z, #z=, [z], [z]=" do
+        specify "exist" do
+          p = Point3D.new
+          p.z = 1
+          p.z.should == 1
+          p["z"].should == 1
+          lambda { p.z = 2    }.should raise_error(Typed::FixedValue)
+          lambda { p["z"] = 2 }.should raise_error(Typed::FixedValue)
+        end
+      end
+    end
+  end
+end

data/spec/scala/modifier_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  include_context "scala_source"
+
+  ######################################################################
+  ### Modifiers: OVERRIDE | LAZY
+
+  # def isModifier: Boolean = in.token match {
+#      case ABSTRACT | FINAL | SEALED | PRIVATE |
+#           PROTECTED | OVERRIDE | IMPLICIT | LAZY => true
+ 
+  # modifiers :     def isLocalModifier: Boolean = in.token match {
+#      case ABSTRACT | FINAL | SEALED | IMPLICIT | LAZY => true
+
+#  def isDclIntro: Boolean = in.token match {
+#      case VAL | VAR | DEF | TYPE => true
+
+#  describe "conflicted variable names" do
+  pending "conflicted variable names" do
+    context "(without override modifier)"
+
+    let(:source) { <<-EOF
+      class T
+        include Typed::Scala
+        
+        val t = String
+      end
+
+      class U < T
+        val t = Fixnum
+      end
+      EOF
+    }
+
+    specify do
+      lambda { scala_source("User", source) }.should raise_error(TypeError)
+    end
+
+    specify do
+      scala_source("User", source)
+      T.vals.should == {}
+    end
+
+    context "(with override modifier)" do
+    end
+  end
+end

data/spec/scala/todo_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  ######################################################################
+  ### TODO
+
+  describe "check method conflictions like [], []=" do
+    specify do
+      pending "will be implemented in version 0.3.0"
+    end
+  end
+
+  context "when val or var are overridden in same context" do
+    specify do
+      pending "will be implemented in version 0.3.0"
+    end
+  end
+
+  context "when val or var are overridden in subclass" do
+    specify do
+      pending "will be implemented in version 0.3.0"
+    end
+  end
+end

data/spec/scala/two_files_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+describe Typed::Scala do
+  include_context "scala_source"
+
+  ######################################################################
+  ### Two files at same time
+
+  context "(two files)" do
+    before { scala_source("A", <<-EOF)
+      class A
+        include Typed::Scala
+        val key = String
+        var val = String
+      end
+      EOF
+    }
+     
+    before { scala_source("B", <<-EOF)
+      class B
+        include Typed::Scala
+        val key = Fixnum
+        var url = String
+      end
+      EOF
+    }
+
+    specify "should be independent" do
+      A.vals.should == { "key" => String }
+      A.vars.should == { "val" => String }
+      B.vals.should == { "key" => Fixnum }
+      B.vars.should == { "url" => String }
+    end
+
+    specify "accessors" do
+      a = A.new
+      b = B.new
+
+      a.key = "foo"
+      a.val = "xyz"
+      b.key = 10000
+      b.url = "http"
+
+      a.key.should == "foo"
+      a.val.should == "xyz"
+      a["key"].should == "foo"
+      a["val"].should == "xyz"
+
+      b.key.should == 10000
+      b.url.should == "http"
+      b["key"].should == 10000
+      b["url"].should == "http"
+    end
+
+    context "read non defined field" do
+      subject { lambda { A.new["xxx"] } }
+      it { should raise_error(Typed::NotDefined) }
+      it { should raise_error(/xxx is not a member of A/) }
+    end
+
+    context "read defined but not initiaized field" do
+      context "[key]" do
+        subject { lambda { A.new["key"] } }
+        it { should raise_error(Typed::NotDefined) }
+        it { should raise_error(/'key' is not initialized/) }
+      end
+
+      context "#key" do
+        subject { lambda { A.new.key } }
+        it { should raise_error(Typed::NotDefined) }
+        it { should raise_error(/'key' is not initialized/) }
+      end
+    end
+
+    context "write non defined field" do
+      subject { lambda { A.new["xxx"] = 1 } }
+      it { should raise_error(Typed::NotDefined) }
+      it { should raise_error(/xxx is not a member of A/) }
+    end
+
+    describe "write twice" do
+      context "val" do
+        subject { lambda { b = B.new; b.key = 0;  b.key = 1 } }
+        it { should raise_error(Typed::FixedValue) }
+        it { should raise_error(/reassignment to key/) }
+      end
+      
+      context "var" do
+        subject { lambda { b = B.new; b.url = "x";  b.url = "y" } }
+        it { should_not raise_error }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,11 @@
 $:.unshift File.expand_path('../../lib', __FILE__)
 
+require 'rubygems'
 require 'rspec'
 require 'typed'
 
+root = Pathname(File.dirname(__FILE__)) + ".."
+Dir[root + "spec/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
   # == Mock Framework
@@ -18,7 +21,6 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
 end
 
-
 def tmp_path(file)
   Pathname(File.dirname(__FILE__)) + "../tmp" + file
 end

data/spec/support/scala.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+shared_context "scala_source" do
+  before { @loaded = [] }
+  after  { @loaded.each{|klass| Object.__send__(:remove_const, klass) if Object.const_defined?(klass) } }
+      
+  def scala_source(klass, code)
+    path = tmp_path("scala/source.rb")
+    path.parent.mkpath
+    path.open("w+"){|f| f.puts(code) }
+    load(path.to_s)
+    @loaded << klass
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: typed
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 7
   prerelease: 
   segments: 
   - 0
   - 2
-  - 7
-  version: 0.2.7
+  - 8
+  version: 0.2.8
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-08-28 00:00:00 Z
+date: 2013-09-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
@@ -81,6 +81,11 @@ files:
 - lib/typed/events.rb
 - lib/typed/hash.rb
 - lib/typed/scala.rb
+- lib/typed/scala/accessors.rb
+- lib/typed/scala/builder.rb
+- lib/typed/scala/parser.rb
+- lib/typed/scala/reflect.rb
+- lib/typed/scala/variables.rb
 - lib/typed/schema.rb
 - lib/typed/version.rb
 - spec/changes_spec.rb
@@ -90,9 +95,16 @@ files:
 - spec/hash_spec.rb
 - spec/merge_spec.rb
 - spec/path_spec.rb
-- spec/scala_spec.rb
+- spec/scala/attrs_spec.rb
+- spec/scala/build_spec.rb
+- spec/scala/core_spec.rb
+- spec/scala/inherit_spec.rb
+- spec/scala/modifier_spec.rb
+- spec/scala/todo_spec.rb
+- spec/scala/two_files_spec.rb
 - spec/schema_spec.rb
 - spec/spec_helper.rb
+- spec/support/scala.rb
 - spec/time_spec.rb
 - typed.gemspec
 homepage: https://github.com/maiha/typed

data/spec/scala_spec.rb

@@ -1,243 +0,0 @@
-require "spec_helper"
-
-describe Typed::Scala do
-  before { @loaded = [] }
-  after  { @loaded.each{|klass| Object.__send__(:remove_const, klass) if Object.const_defined?(klass) } }
-      
-  def source(klass, code)
-    path = tmp_path("scala/inline.rb")
-    path.parent.mkpath
-    path.open("w+"){|f| f.puts(code) }
-    load(path.to_s)
-    @loaded << klass
-  end
-
-  ######################################################################
-  ### Basic usage
-
-  describe "User" do
-    before { source("User", <<-EOF)
-      class User
-        include Typed::Scala
-
-        val key  = String
-        var name = String
-        var age  = Fixnum
-      end
-      EOF
-    }
-     
-    context "(class)" do
-      subject { User }
-      its(:vals) { should be_kind_of ActiveSupport::OrderedHash }
-      its(:vals) { should == { "key" => String } }
-      its(:vars) { should be_kind_of ActiveSupport::OrderedHash }
-      its(:vars) { should == { "name" => String, "age" => Fixnum } }
-    end
-
-    context "(instance)" do
-      let(:user) { User.new }
-      subject    { user}
-
-      it { should respond_to(:key) }
-      it { should respond_to(:name) }
-      it { should respond_to(:age) }
-      it { should_not respond_to(:xxx) }
-      it { should respond_to(:attrs) }
-      it { should respond_to(:[]) }
-      it { should respond_to(:[]=) }
-
-      describe "#name=" do
-        specify "accept 'maiha'" do
-          (user.name = 'maiha').should == 'maiha'
-        end
-
-        specify "reject 100" do
-          lambda { user.name = 100 }.should raise_error(TypeError)
-        end
-      end
-    end
-  end
-
-  ######################################################################
-  ### Two files at same time
-
-  context "(two files)" do
-    before { source("A", <<-EOF)
-      class A
-        include Typed::Scala
-        val key = String
-        var val = String
-      end
-      EOF
-    }
-     
-    before { source("B", <<-EOF)
-      class B
-        include Typed::Scala
-        val key = Fixnum
-        var url = String
-      end
-      EOF
-    }
-
-    specify "should be independent" do
-      A.vals.should == { "key" => String }
-      A.vars.should == { "val" => String }
-      B.vals.should == { "key" => Fixnum }
-      B.vars.should == { "url" => String }
-    end
-
-    specify "accessors" do
-      a = A.new
-      b = B.new
-
-      a.key = "foo"
-      a.val = "xyz"
-      b.key = 10000
-      b.url = "http"
-
-      a.key.should == "foo"
-      a.val.should == "xyz"
-      a["key"].should == "foo"
-      a["val"].should == "xyz"
-
-      b.key.should == 10000
-      b.url.should == "http"
-      b["key"].should == 10000
-      b["url"].should == "http"
-    end
-
-    context "read non defined field" do
-      subject { lambda { A.new["xxx"] } }
-      it { should raise_error(Typed::NotDefined) }
-      it { should raise_error(/xxx is not a member of A/) }
-    end
-
-    context "read defined but not initiaized field" do
-      context "[key]" do
-        subject { lambda { A.new["key"] } }
-        it { should raise_error(Typed::NotDefined) }
-        it { should raise_error(/'key' is not initialized/) }
-      end
-
-      context "#key" do
-        subject { lambda { A.new.key } }
-        it { should raise_error(Typed::NotDefined) }
-        it { should raise_error(/'key' is not initialized/) }
-      end
-    end
-
-    context "write non defined field" do
-      subject { lambda { A.new["xxx"] = 1 } }
-      it { should raise_error(Typed::NotDefined) }
-      it { should raise_error(/xxx is not a member of A/) }
-    end
-
-    describe "write twice" do
-      context "val" do
-        subject { lambda { b = B.new; b.key = 0;  b.key = 1 } }
-        it { should raise_error(Typed::FixedValue) }
-        it { should raise_error(/reassignment to key/) }
-      end
-      
-      context "var" do
-        subject { lambda { b = B.new; b.url = "x";  b.url = "y" } }
-        it { should_not raise_error }
-      end
-    end
-  end
-
-  ######################################################################
-  ### Inheritance
-
-  context "(Point3D < Point2D)" do
-    before { source("Point2D", <<-EOF)
-      class Point2D
-        include Typed::Scala
-        val x = Fixnum
-        val y = Fixnum
-      end
-      EOF
-    }
-     
-    before { source("Point3D", <<-EOF)
-      class Point3D < Point2D
-        val z = Fixnum
-      end
-      EOF
-    }
-
-    context "Point2D" do
-      specify "contains x,y" do
-        Point2D.vals.keys.should == %w( x y )
-      end
-
-      describe "#x, #x=" do
-        specify "exist" do
-          p = Point2D.new
-          p.x = 1
-          p.x.should == 1
-          lambda { p.x = 2 }.should raise_error(Typed::FixedValue)
-        end
-      end
-
-      describe "#z" do
-        specify "not exist" do
-          p = Point2D.new
-          lambda { p["z"] = 3 }.should raise_error(Typed::NotDefined)
-          lambda { p.z = 3    }.should raise_error(NoMethodError)
-        end
-      end
-    end
-
-    context "Point3D" do
-      specify "contains x,y,z" do
-        Point3D.vals.keys.should == %w( x y z )
-      end
-
-      describe "#x, #x=, [x], [x]=" do
-        specify "exist" do
-          p = Point3D.new
-          p.x = 1
-          p.x.should == 1
-          p["x"].should == 1
-          lambda { p.x = 2    }.should raise_error(Typed::FixedValue)
-          lambda { p["x"] = 2 }.should raise_error(Typed::FixedValue)
-        end
-      end
-
-      describe "#z, #z=, [z], [z]=" do
-        specify "exist" do
-          p = Point3D.new
-          p.z = 1
-          p.z.should == 1
-          p["z"].should == 1
-          lambda { p.z = 2    }.should raise_error(Typed::FixedValue)
-          lambda { p["z"] = 2 }.should raise_error(Typed::FixedValue)
-        end
-      end
-    end
-  end
-
-  ######################################################################
-  ### TODO
-
-  describe "check method conflictions like [], []=" do
-    specify do
-      pending "will be implemented in version 0.3.0"
-    end
-  end
-
-  context "when val or var are overridden in same context" do
-    specify do
-      pending "will be implemented in version 0.3.0"
-    end
-  end
-
-  context "when val or var are overridden in subclass" do
-    specify do
-      pending "will be implemented in version 0.3.0"
-    end
-  end
-end