typed 0.2.6 → 0.2.7

data/.gitignore

@@ -3,3 +3,5 @@
 Gemfile.lock
 pkg/*
 tmp
+vendor
+.ruby-version

data/README.rdoc

@@ -82,6 +82,26 @@ We need some typed variables to avoid silly and stealth mistakes.
   => 1
 
 
+== Experimental : Typed::Scala
+
+Love 'val', 'var' of Scala!!
+
+  # [NOTE] val and var must be written in source files.
+  % cat user.rb
+  class User
+    include Typed::Scala
+    val nick  = String
+    var pass  = String
+  end
+  % bundle exec irb -r typed -r user
+  >> u = User.new
+  >> u.nick
+  Typed::NotDefined: 'nick' is not initialized
+  >> u.nick = "maiha"
+  >> u.nick = "no name"
+  => Typed::FixedValue: reassignment to nick
+
+
 == REQUIREMENTS:
 
 * activesupport gem

data/lib/typed.rb

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

data/lib/typed/scala.rb

@@ -1,59 +1,122 @@
 module Typed
   module Scala
-    def vars
-      unless @vars
-        vars = Typed::Hash.new
-        self.class.types.each_pair do |name, obj|
-#          vars.default[name] = obj
-          vars[name] = obj
+
+    ######################################################################
+    ### 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
-        @vars = vars
+        attrs[key.to_s] = val
+      else
+        raise Typed::NotDefined, "#{key} is not a member of #{self.class}"
       end
-      return @vars
     end
 
-    def types
-      self.class.types
+    ######################################################################
+    ### 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 types
-        @types ||= {}
+
+      def self.apply(klass, type, caller, obj)
+        name = parse(klass, type, caller)
+        define(klass, type, name, obj)
       end
 
-      def register_var(name, obj)
-        types[name] = obj
+      def self.define(klass, type, name, obj)
+        vars = klass.__send__("#{type}s")
+        vars[name] = obj
         
-        define_method(name) { vars[name.to_s] }
-        define_method("#{name}=") {|v| vars[name.to_s] = v }
+        klass.class_eval do
+          define_method(name) { self[name.to_s] }
+          define_method("#{name}=") {|v| self[name.to_s] = v }
+        end
       end
 
-      def parse_var_name(caller)
+      def self.parse(klass, type, caller)
         # "/tmp/adsvr/dsl.rb:23"
         case caller
         when %r{^(.*?):(\d+)}o
-          file = $1
-          line = $2.to_i
-          @lines ||= File.readlines(file)
-          case @lines[line-1].to_s
-          when /^\s*var\s+(\S+)\s+=/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 file:#{file} (line: #{line})"
+            raise ParseError, "#{self} from #{caller}"
           end
         else
-          raise ParseError, "#{self} from caller:#{caller[0]}"
+          raise ParseError, "#{self} from caller:#{caller}"
         end
       end
 
-      def var(obj)
-        name = parse_var_name(caller[0])
-        register_var(name, obj)
+      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
 
+    ######################################################################
+    ### module
+
     def self.included(klass)
+      super
+
+      klass.extend Scala::Val
       klass.extend Scala::Var
     end
   end

data/lib/typed/schema.rb

@@ -45,6 +45,10 @@ module Typed
       @types[key.to_s].value
     end
 
+    def exist?(key)
+      @types.key?(key.to_s)
+    end
+
     def declare!(key, declare)
       case declare.must.be.kind_of(Explicit, Implicit)
       when Explicit

data/lib/typed/version.rb

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

data/spec/scala_spec.rb

@@ -1,56 +1,243 @@
 require "spec_helper"
 
 describe Typed::Scala do
-  before { write_and_load(source) }
-
-  let(:source) { commented_source.gsub(/^\s*#/m, '') }
-  let(:user)   { User.new }
-  subject      { user}
-
-  def write_and_load(code)
+  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
 
-  context "User" do
-    # comment outed for the editor issues
-    let(:commented_source) { <<-EOF
-      # class User
-      #   include Typed::Scala
-      # 
-      #   var name = String
-      #   var age  = Fixnum
-      # 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(:[]=) }
 
-    it { should respond_to(:name) }
-    it { should respond_to(:age) }
-    it { should_not respond_to(:xxx) }
+      describe "#name=" do
+        specify "accept 'maiha'" do
+          (user.name = 'maiha').should == 'maiha'
+        end
 
-    describe "#types" do
-      its(:types) { should == {
-          "age"  => Fixnum,
-          "name" => String,
-        } }
+        specify "reject 100" do
+          lambda { user.name = 100 }.should raise_error(TypeError)
+        end
+      end
     end
+  end
 
-    describe ".types" do
-      specify "same as User#type" do
-        user.types.should == User.types
+  ######################################################################
+  ### 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
 
-    describe "#name=" do
-      specify "accept 'maiha'" do
-        (user.name = 'maiha').should == 'maiha'
+    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
 
-      specify "reject 100" do
-        lambda { user.name = 100 }.should raise_error(TypeError)
+      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

data/spec/schema_spec.rb

@@ -1,6 +1,24 @@
 require "spec_helper"
 
 describe Typed::Schema do
+  describe "#exist?" do
+    let(:hash)   { Typed::Hash.new }
+    let(:schema) { hash.schema }
+
+    context "(not exist)" do
+      specify "false" do
+        schema.exist?(:a).should == false
+      end
+    end
+
+    context "(exist)" do
+      before { hash[:a] = String }
+      specify "true" do
+        schema.exist?(:a).should == true
+      end
+    end
+  end
+
   describe ".schema?" do
     delegate :schema?, :to => "Typed::Schema"
 

data/spec/spec_helper.rb

@@ -3,6 +3,22 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'rspec'
 require 'typed'
 
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end
+
+
 def tmp_path(file)
   Pathname(File.dirname(__FILE__)) + "../tmp" + file
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: typed
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 2
-  - 6
-  version: 0.2.6
+  - 7
+  version: 0.2.7
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-08-26 00:00:00 Z
+date: 2013-08-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport