striuct 0.3.0 → 0.3.1

data/test/test_striuct_subclass_hashlike.rb

@@ -0,0 +1,153 @@
+require_relative 'helper'
+
+class TestStriuctHashLike < Test::Unit::TestCase
+
+  Sth = Striuct.new :foo, :bar, :hoge
+
+  def test_empty?
+    sth = Sth[hoge: 7, foo: 8]
+    assert_equal false, sth.empty?
+    sth.each_member{|name|sth[name] = nil}
+    assert_equal false, sth.empty?
+    sth.each_member{|name|sth.unassign name}
+    assert_equal true, sth.empty?
+  end
+  
+  def test_has_value?
+    sth = Sth[hoge: 7, foo: 8]
+    assert_equal true, sth.value?(7)
+    assert_equal true, sth.value?(8)
+    assert_equal false, sth.value?(9)
+    assert_equal false, sth.value?(nil)
+  end
+  
+  def test_select!
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+  
+    assert_kind_of Enumerator, enum = sth.select!
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+
+    assert_equal nil, sth2.select!{|k, v|true}
+    assert_equal sth3, sth3.select!{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.foo
+    assert_equal true, sth3.assign?(:hoge)
+    assert_equal false, sth3.assign?(:foo)
+    assert_equal 7, sth3.hoge    
+  end
+
+  def test_keep_if
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+    
+    assert_kind_of Enumerator, enum = sth.keep_if
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+    
+    assert_equal sth2, sth2.keep_if{|k, v|true}
+    assert_equal sth3, sth3.keep_if{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.foo
+    assert_equal true, sth3.assign?(:hoge)
+    assert_equal false, sth3.assign?(:foo)
+    assert_equal 7, sth3.hoge
+  end
+  
+  def test_reject!
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+    
+    assert_kind_of Enumerator, enum = sth.reject!
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+    
+    enum.rewind
+    assert_equal [:foo, 8], enum.next
+
+    assert_equal nil, sth2.reject!{|k, v|false}
+    assert_equal sth3, sth3.reject!{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.hoge
+    assert_equal false, sth3.assign?(:hoge)
+    assert_equal true, sth3.assign?(:foo)
+    assert_equal 8, sth3.foo
+  end
+
+  def test_delete_if
+    sth = Sth[hoge: 7, foo: 8]
+    sth2, sth3 = sth.dup, sth.dup
+    
+    assert_kind_of Enumerator, enum = sth.delete_if
+
+    assert_equal [:foo, 8], enum.next
+    assert_equal [:bar, nil], enum.next
+    assert_equal [:hoge, 7], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+
+    assert_equal sth2, sth2.delete_if{|k, v|false}
+    assert_equal sth3, sth3.delete_if{|k, v|k == :hoge && v == 7}
+    assert_equal nil, sth3.hoge
+    assert_equal false, sth3.assign?(:hoge)
+    assert_equal true, sth3.assign?(:foo)
+    assert_equal 8, sth3.foo
+  end
+  
+  def test_assoc
+    sth = Sth[hoge: 7, foo: 8]
+
+    assert_equal [:foo, 8], sth.assoc(:foo)
+    assert_equal [:bar, nil], sth.assoc(:bar)
+    assert_equal [:hoge, 7], sth.assoc(:hoge)
+    
+    assert_raises NameError do
+      sth.assoc(:dummy)
+    end
+  end
+
+  def test_rassoc
+    sth = Sth[hoge: 7, foo: 7]
+
+    assert_equal [:foo, 7], sth.rassoc(7)
+    assert_equal [:bar, nil], sth.rassoc(nil)
+    assert_equal nil, sth.rassoc(9)
+  end
+
+  def test_flatten
+    sth = Sth[hoge: 7, foo: 8, bar: [1, 2]]
+    assert_equal [:foo, 8, :bar, [1, 2], :hoge, 7], sth.flatten
+    assert_equal [:foo, 8, :bar, [1, 2], :hoge, 7], sth.flatten(1)
+    assert_equal [:foo, 8, :bar, 1, 2, :hoge, 7], sth.flatten(2)
+    assert_equal [:foo, 8, :bar, 1, 2, :hoge, 7], sth.flatten(3)
+    assert_equal [:foo, 8, :bar, 1, 2, :hoge, 7], sth.flatten(-1)
+  end
+  
+  def test_select
+    sth = Sth[hoge: 7, foo: 8]
+
+    assert_kind_of Enumerator, sth.select
+    
+    assert_equal Sth[hoge: 7], sth.select{|k, v|k == :hoge}
+  end
+
+  def test_reject
+    sth = Sth[hoge: 7, foo: 8]
+
+    assert_kind_of Enumerator, sth.reject
+    
+    assert_equal Sth[foo: 8], sth.reject{|k, v|k == :hoge}
+  end
+
+end

data/test/test_striuct_subclass_inference.rb

@@ -0,0 +1,51 @@
+require_relative 'helper'
+
+class TestStriuctInference < Test::Unit::TestCase
+
+  def test_inference
+    klass = Striuct.define do
+      member :n, Numeric, inference: true
+      member :m, ANYTHING?, inference: true
+    end
+    
+    sth, sth2 = klass.new, klass.new
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.n = '1'
+    end
+    
+    sth.n = 1.1
+    
+    assert_equal 1.1, sth.n
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.n = 1
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      sth2.n = 1
+    end
+    
+    sth.n = 2.1
+    
+    assert_equal 2.1, sth.n
+    
+    
+    sth2.m = 1
+    
+    assert_equal 1, sth2.m
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.m = 1.0
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      sth2.m = 1.0
+    end
+    
+    sth.m = 2
+    
+    assert_equal 2, sth.m
+  end
+
+end

data/test/test_striuct_subclass_inheritable.rb

@@ -0,0 +1,58 @@
+require_relative 'helper'
+
+class TestStriuctInheritable < Test::Unit::TestCase
+
+  Sth = Striuct.define do
+    member :foo, String
+    member :bar, OR(nil, Fixnum)
+  end
+  
+  class SubSth < Sth
+    member :hoge, OR(nil, 1..3)
+  end
+  
+  class SubSubSth < SubSth
+    member :rest, AND(/\d/, Symbol)
+  end
+  
+  def test_inherit
+    assert_equal [*Sth.members, :hoge], SubSth.members
+    sth = Sth.new
+    substh = SubSth.new
+
+    assert_raises Validation::InvalidWritingError do
+      substh.bar = 'str'
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      substh.hoge = 4
+    end
+    
+    assert_raises NoMethodError do
+      sth.hoge = 3
+    end
+    
+    assert_raises NoMethodError do
+      substh.rest = :a4
+    end
+    
+    subsubsth = SubSubSth.new
+    
+    assert_raises Validation::InvalidWritingError do
+      subsubsth.rest = 4
+    end
+    
+    subsubsth.rest = :a4
+    
+    assert_equal :a4, subsubsth[:rest]
+    
+    assert_equal true, Sth.__send__(:closed?)
+    assert_equal false, SubSth.__send__(:closed?)
+    SubSth.__send__(:close)
+    assert_equal true, SubSth.__send__(:closed?)
+    assert_equal false, SubSubSth.__send__(:closed?)
+    SubSubSth.__send__(:close)
+    assert_equal true, SubSubSth.__send__(:closed?)
+  end
+
+end

data/test/test_striuct_subclass_instance.rb

@@ -0,0 +1,289 @@
+require_relative 'helper'
+
+class TestStriuctSubclassInstance1 < Test::Unit::TestCase
+  class User < Striuct.new
+    member :id, Integer
+    member :last_name, /\A\w+\z/
+    member :family_name, /\A\w+\z/
+    member :address, /\A((\w+) ?)+\z/
+    member :age, ->age{(20..140).include? age}
+  end
+
+  def test_setter
+    user = User.new
+    user[:last_name] = 'foo'
+    assert_equal user.last_name, 'foo'
+    user.last_name = 'bar'
+    assert_equal user[:last_name], 'bar'
+    
+    assert_raises Validation::InvalidWritingError do
+      user[:last_name] = 'foo s'
+    end
+  
+    assert_raises Validation::InvalidWritingError do
+      User.new 'asda'
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      user.age = 19
+    end
+  end
+  
+  def test_equal
+    user1 = User.new 11218, 'taro'
+    user2 = User.new 11218, 'taro'
+    assert_equal true, (user1 == user2)
+    user2.last_name = 'ichiro'
+    assert_equal false, (user1 == user2)
+  end
+end
+
+class TestStriuctSubclassInstance2 < Test::Unit::TestCase
+  class User < Striuct.new
+    member :id, Integer
+    member :last_name, /\A\w+\z/
+    member :family_name, /\A\w+\z/
+    member :address, /\A((\w+) ?)+\z/
+    member :age, ->age{(20..140).include? age}
+  end
+  
+  def setup
+    @user = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
+  end
+
+  def test_reader
+    assert_equal @user[1], 'taro'
+    assert_equal @user[:last_name], 'taro'
+    assert_equal @user.last_name, 'taro'
+  end
+
+  def test_setter_pass
+    assert_equal((@user.id = 2139203509295), 2139203509295)
+    assert_equal @user.id, 2139203509295
+    assert_equal((@user.last_name = 'jiro'), 'jiro')
+    assert_equal @user.last_name, 'jiro'
+    assert_equal((@user.age = 40), 40)
+    assert_equal @user.age, 40
+  end
+  
+  def test_setter_fail
+    assert_raises Validation::InvalidWritingError do
+      @user.id = 2139203509295.0
+    end
+
+    assert_raises Validation::InvalidWritingError do
+      @user.last_name = 'ignore name'
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      @user.age = 19
+    end
+  end
+  
+  def test_strict?
+    assert_same @user.sufficient?(:last_name), true
+    assert_same @user.strict?, true
+    assert_same @user.sufficient?(:last_name), true
+    @user.last_name.clear
+    assert_same @user.sufficient?(:last_name), false
+    assert_same @user.strict?, false
+  end
+end
+
+class TestStriuctSubclassInstance3 < Test::Unit::TestCase
+  class User < Striuct.new
+    member :id, Integer
+    member :last_name, /\A\w+\z/
+    member :family_name, /\A\w+\z/
+    member :address, /\A((\w+) ?)+\z/
+    member :age, ->age{(20..140).include? age}
+  end
+
+  def setup
+    @user = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
+    @user2 = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
+  end
+  
+  def test_to_s
+    /\b(taro)\b/ =~ @user.to_s
+    assert_equal 'taro', $1
+  end
+
+  def test_inspect
+    /\b(taro)\b/ =~ @user.inspect
+    assert_equal 'taro', $1
+  end
+
+  def test_members
+    assert_equal @user.members, [:id, :last_name, :family_name, :address, :age]
+  end
+  
+  def test_delegate_class_method
+    assert_equal @user.members, User.members
+    assert_equal @user.size, User.size
+    assert_equal @user.member?(:age), User.member?(:age)
+  end
+  
+  def test_each
+    assert_same @user, @user.each{}
+    assert_kind_of Enumerator, enum = @user.each
+    assert_equal enum.next, 9999
+    assert_equal enum.next, 'taro'
+  end
+  
+  def test_each_member
+    assert_same @user, @user.each_member{}
+    assert_kind_of Enumerator, enum = @user.each_member
+    assert_equal :id, enum.next
+    assert_equal :last_name, enum.next
+    assert_equal :family_name, enum.next
+    assert_equal :address, enum.next
+    assert_equal :age, enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+  end
+  
+  def test_each_index
+    assert_same @user, @user.each_index{}
+    assert_kind_of Enumerator, enum = @user.each_index
+    assert_equal 0, enum.next
+    assert_equal 1, enum.next
+    assert_equal 2, enum.next
+    assert_equal 3, enum.next
+    assert_equal 4, enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+  end
+  
+  def test_each_with_index
+    assert_same @user, @user.each_with_index{}
+    assert_kind_of Enumerator, @user.each_with_index
+    
+    r = []
+    @user.each_with_index do |value, index|
+      r << [value, index]
+    end
+    
+    assert_equal [@user.each_value.to_a, @user.each_index.to_a].transpose, r
+  end
+
+  def test_each_member_with_index
+    assert_same @user, @user.each_member_with_index{}
+    assert_kind_of Enumerator, @user.each_member_with_index
+    
+    r = []
+    @user.each_member_with_index do |name, index|
+      r << [name, index]
+    end
+    
+    assert_equal [@user.each_key.to_a, @user.each_index.to_a].transpose, r
+  end
+
+  def test_values
+    assert_equal @user.values, [9999, 'taro', 'yamada', 'Tokyo Japan', 30]
+  end
+  
+  def test_values_at
+    assert_equal(@user.values_at(4, 0, (2..4)), [30, 9999, 'yamada', 'Tokyo Japan', 30])
+  end
+
+  def test_hash
+    assert_kind_of Integer, @user.hash
+    assert_equal @user.hash, @user2.hash
+  end
+  
+  def test_eql?
+    assert_equal true, @user.eql?(@user2)
+    assert_equal true, @user2.eql?(@user)
+    assert_equal false, @user.eql?(User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 31)
+  end
+end
+
+
+class TestStriuctSubclassInstance4 < Test::Unit::TestCase
+  class Sth < Striuct.new
+    member :bool, OR(true, false)
+    member :sth
+    protect_level :struct
+    member :lambda, OR(->v{v % 3 == 2}, ->v{v.kind_of? Float})
+  end
+  
+  def setup
+    @sth = Sth.new
+  end
+
+  def test_accessor
+    @sth.bool = true
+    assert_same true, @sth.bool
+    @sth.bool = false
+    assert_same false, @sth.bool
+    
+    assert_raises Validation::InvalidWritingError do
+      @sth.bool = nil
+    end
+    
+    @sth.sth = 1
+    assert_same 1, @sth.sth
+
+    @sth.sth = 'String'
+    assert_equal 'String', @sth.sth
+    
+    @sth.sth = Class.class
+    assert_same Class.class, @sth.sth
+    
+    assert_raises Validation::InvalidWritingError do
+      @sth.lambda = 9
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      @sth.lambda = 7
+    end
+    
+    @sth.lambda = 8
+    assert_same 8, @sth.lambda
+
+    @sth.lambda = 9.0
+    assert_equal 9.0, @sth.lambda
+  end
+end
+
+class TestStriuctHashKeyable < Test::Unit::TestCase
+
+  Sth = Striuct.new :foo, :bar, :hoge
+
+  def test_hash
+    sth1 = Sth[hoge: 7, foo: 8]
+    sth2 = Sth[hoge: 7, foo: 8]
+    assert_equal true, sth1.eql?(sth2)
+    assert_equal true, sth2.eql?(sth1)
+    assert_equal sth1.hash, sth2.hash
+    assert_equal true, {sth1 => 1}.has_key?(sth2)
+    assert_equal true, {sth2 => 1}.has_key?(sth1)
+    assert_equal 1, {sth1 => 1}[sth2]
+    assert_equal 1, {sth2 => 1}[sth1]
+  end
+
+end
+
+class TestStriuctEachPair < Test::Unit::TestCase
+
+  Sth = Striuct.define do
+    member :name
+    member :age
+  end
+  
+  def test_each_pair_with_index
+    sth = Sth.new 'a', 10
+    assert_same sth, sth.each_pair_with_index{}
+    
+    enum = sth.each_pair_with_index    
+    assert_equal [:name, 'a', 0], enum.next
+    assert_equal [:age, 10, 1], enum.next
+    assert_raises StopIteration do
+      enum.next
+    end
+  end
+
+end

data/test/test_striuct_subclass_lock.rb

@@ -0,0 +1,40 @@
+require_relative 'helper'
+
+class TestStriuctLock < Test::Unit::TestCase
+
+  Sth = Striuct.new :foo, :bar
+  Sth.__send__ :close
+  
+  def test_lock
+    sth = Sth.new
+    assert_equal false, sth.lock?(:foo)
+    assert_equal false, sth.lock?(:bar)
+    assert_equal false, sth.secure?
+    sth.lock :bar
+    assert_equal true, sth.lock?(:bar)
+    assert_equal false, sth.secure?
+  
+    assert_raises RuntimeError do
+     sth.bar = 1
+    end
+   
+    sth.__send__ :unlock, :bar
+    
+    assert_equal false, sth.lock?(:bar)
+    
+    sth.bar = 1
+    assert_equal 1, sth.bar
+    
+    sth.lock
+    assert_equal true, sth.lock?(:foo)
+    assert_equal true, sth.lock?(:bar)
+    assert_equal true, sth.lock?
+    
+    assert_raises RuntimeError do
+      sth.foo = 1
+    end
+    
+    assert_equal true, sth.secure?
+  end
+
+end

data/test/test_striuct_subclass_safetynaming.rb

@@ -0,0 +1,72 @@
+require_relative 'helper'
+
+class TestStriuctSafetyNaming < Test::Unit::TestCase
+
+  def test_cname?
+    klass = Striuct.new
+    assert_same false, klass.cname?(Object)
+    assert_same false, klass.cname?('m?')
+    assert_same false, klass.cname?('__foo__')
+    assert_same false, klass.cname?('a b')
+    assert_same false, klass.cname?('object_id')
+    assert_same false, klass.cname?('to_ary')
+    assert_same true, klass.cname?('foo')
+    klass.__send__ :protect_level, :warning
+    assert_same false, klass.cname?('m?')
+    assert_same false, klass.cname?('__foo__')
+    assert_same false, klass.cname?('a b')
+    assert_same false, klass.cname?('object_id')
+    assert_same false, klass.cname?('to_ary')
+    assert_same true, klass.cname?('foo')
+    klass.__send__ :protect_level, :struct
+    assert_same true, klass.cname?('m?')
+    assert_same true, klass.cname?('__foo__')
+    assert_same true, klass.cname?('a b')
+    assert_same true, klass.cname?('object_id')
+    assert_same true, klass.cname?('to_ary')
+    assert_same true, klass.cname?('foo')
+  end
+  
+  def test_protect
+    klass = Striuct.new
+    assert_raises NameError do
+      klass.class_eval do
+        member ''
+      end
+    end
+    
+    assert_raises NameError do
+      klass.class_eval do
+        member :'a b'
+      end
+    end
+
+    assert_raises NameError do
+      klass.class_eval do
+        member :'__send__'
+      end
+    end
+
+    assert_raises NameError do
+      klass.class_eval do
+        member :'__foo__'
+      end
+    end
+    
+    assert_raises NameError do
+      klass.class_eval do
+        member :'m?'
+      end
+    end
+  
+    assert_same false, klass.member?('m?')
+    
+    klass.class_eval do
+      protect_level :struct
+      member :'m?'
+    end
+    
+    assert_same true, klass.member?('m?')
+  end
+
+end