striuct 0.3.5.1 → 0.4.0

data/test/test_subc-f_name.rb

@@ -0,0 +1,525 @@
+require_relative 'helper'
+
+class Test_Striuct_Subclass_Name < Test::Unit::TestCase
+  
+  # for peep
+  origin_autonyms = nil
+  origin_aliases = nil
+
+  Subclass = Striuct.define do
+    origin_autonyms = @autonyms
+    origin_aliases  = @aliases
+
+    member :foo
+    member :bar
+    alias_member :als_foo, :foo
+
+    close_member
+  end.freeze
+
+  INSTANCE = Subclass.new.freeze
+  
+  TYPE_PAIRS = {
+    Class: Subclass,
+    Instance: INSTANCE
+  }.freeze
+
+  [:_autonyms].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.private_methods.include?(callee)
+        
+        assert_raises NoMethodError do
+          reciever.public_send(callee)
+        end
+        
+        assert_same origin_autonyms, reciever.__send__(callee)
+      end
+    end
+  end
+
+  [:autonyms, :members].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+        ret = reciever.public_send(callee)
+        assert_not_same origin_autonyms, ret
+        assert_equal origin_autonyms, ret
+        
+        10.times do
+          ret2 = reciever.public_send(callee)
+          assert_not_same ret, ret2
+          assert_equal ret, ret2
+        end
+      end
+    end
+  end
+  
+  [:all_members].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+        ret = reciever.public_send(callee)
+        assert_equal [*origin_autonyms, :als_foo], ret
+        
+        10.times do
+          ret2 = reciever.public_send(callee)
+          assert_not_same ret, ret2
+          assert_equal ret, ret2
+        end
+      end
+    end
+  end
+  
+  [:aliases].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+        ret = reciever.public_send(callee)
+        assert_not_same(origin_aliases, ret)
+        assert_equal({:als_foo => :foo}, ret)
+        
+        10.times do
+          ret2 = reciever.public_send(callee)
+          assert_not_same(origin_aliases, ret2)
+          assert_not_same ret, ret2
+          assert_equal ret, ret2
+        end
+      end
+    end
+  end
+
+  [:autonym_for_alias].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+
+        assert_raises NoMethodError, TypeError do
+          reciever.public_send(callee, BasicObject.new)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, Object.new)
+        end
+        
+        assert_raises NameError do
+          reciever.public_send(callee, :foo)
+        end
+
+        assert_same :foo, reciever.public_send(callee, :als_foo)
+        
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'foo')
+        end
+
+        assert_same :foo, reciever.public_send(callee, 'als_foo')
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 0)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 0.9)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :bar)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :als_bar)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'bar')
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_bar')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 1)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 1.9)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :none)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :als_none)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'none')
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_none')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 2)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 2.9)
+        end
+      end
+    end
+  end
+
+  [:autonym_for_member].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+
+        assert_raises NoMethodError, TypeError do
+          reciever.public_send(callee, BasicObject.new)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, Object.new)
+        end
+
+        assert_same :foo, reciever.public_send(callee, :foo)
+        assert_same :foo, reciever.public_send(callee, :als_foo)
+        assert_same :foo, reciever.public_send(callee, 'foo')
+        assert_same :foo, reciever.public_send(callee, 'als_foo')
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 0)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 0.9)
+        end
+
+        assert_same :bar, reciever.public_send(callee, :bar)
+        
+        assert_raises NameError do
+          reciever.public_send(callee, :als_bar)
+        end
+
+        assert_same :bar, reciever.public_send(callee, 'bar')
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_bar')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 1)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 1.9)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :none)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :als_none)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'none')
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_none')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 2)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 2.9)
+        end
+      end
+    end
+  end
+
+
+  [:autonym_for_index].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+
+        assert_raises NoMethodError, TypeError do
+          reciever.public_send(callee, BasicObject.new)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, Object.new)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, :foo)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, :als_foo)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 'foo')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 'als_foo')
+        end
+
+        assert_same :foo, reciever.public_send(callee, 0)
+        assert_same :foo, reciever.public_send(callee, 0.9)
+        assert_same :foo, reciever.public_send(callee, -2)
+        assert_same :foo, reciever.public_send(callee, -2.9)
+
+        assert_raises TypeError do
+          reciever.public_send(callee, :bar)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, :als_bar)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 'bar')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 'als_bar')
+        end
+
+        assert_same :bar, reciever.public_send(callee, 1)
+        assert_same :bar, reciever.public_send(callee, 1.9)
+        assert_same :bar, reciever.public_send(callee, -1)
+        assert_same :bar, reciever.public_send(callee, -1.9)
+
+        assert_raises TypeError do
+          reciever.public_send(callee, :none)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, :als_none)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 'none')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 'als_none')
+        end
+
+        assert_raises IndexError do
+          reciever.public_send(callee, 2)
+        end
+
+        assert_raises IndexError do
+          reciever.public_send(callee, 2.9)
+        end
+
+        assert_raises IndexError do
+          reciever.public_send(callee, -3)
+        end
+
+        assert_raises IndexError do
+          reciever.public_send(callee, -3.9)
+        end
+      end
+    end
+  end
+
+  [:autonym_for_key].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+
+        assert_raises KeyError do
+          reciever.public_send(callee, BasicObject.new)
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, Object.new)
+        end
+
+        assert_same :foo, reciever.public_send(callee, :foo)
+        assert_same :foo, reciever.public_send(callee, :als_foo)
+        assert_same :foo, reciever.public_send(callee, 'foo')
+        assert_same :foo, reciever.public_send(callee, 'als_foo')
+        assert_same :foo, reciever.public_send(callee, 0)
+        assert_same :foo, reciever.public_send(callee, 0.9)
+        assert_same :foo, reciever.public_send(callee, -2)
+        assert_same :foo, reciever.public_send(callee, -2.9)
+
+        assert_same :bar, reciever.public_send(callee, :bar)
+        
+        assert_raises KeyError do
+          assert_same :bar, reciever.public_send(callee, :als_bar)
+        end
+
+        assert_same :bar, reciever.public_send(callee, 'bar')
+
+        assert_raises KeyError do
+          assert_same :bar, reciever.public_send(callee, 'als_bar')
+        end
+
+        assert_same :bar, reciever.public_send(callee, 1)
+        assert_same :bar, reciever.public_send(callee, 1.9)
+        assert_same :bar, reciever.public_send(callee, -1)
+        assert_same :bar, reciever.public_send(callee, -1.9)
+
+        assert_raises KeyError do
+          reciever.public_send(callee, :none)
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, :als_none)
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, 'none')
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, 'als_none')
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, 2)
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, 2.9)
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, -3)
+        end
+
+        assert_raises KeyError do
+          reciever.public_send(callee, -3.9)
+        end
+      end
+    end
+  end
+
+  [:aliases_for_autonym].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same true, reciever.public_methods.include?(callee)
+
+        assert_raises NoMethodError, TypeError do
+          reciever.public_send(callee, BasicObject.new)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, Object.new)
+        end
+       
+        assert_equal [:als_foo], reciever.public_send(callee, :foo)
+        
+        assert_raises NameError do
+          reciever.public_send(callee, :als_foo)
+        end
+
+        assert_equal [:als_foo], reciever.public_send(callee, 'foo')
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_foo')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 0)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 0.9)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :bar)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :als_bar)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'bar')
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_bar')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 1)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 1.9)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :none)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, :als_none)
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'none')
+        end
+
+        assert_raises NameError do
+          reciever.public_send(callee, 'als_none')
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 2)
+        end
+
+        assert_raises TypeError do
+          reciever.public_send(callee, 2.9)
+        end        
+      end
+    end
+  end
+
+  aliase_for_autonym_ext_pairs = {}.tap {|h|
+    h[:Class] = Striuct.define do
+      member :foo
+      alias_member :als1_foo, :foo
+      member :bar
+      alias_member :als1_bar, :bar
+      alias_member :als2_foo, :foo
+      alias_member :als3_foo, :foo
+      member :xyz
+    end.freeze
+
+    h[:Instance] = h[:Class].new.freeze 
+  }.freeze
+
+  [:aliases_for_autonym].each do |callee|
+    aliase_for_autonym_ext_pairs.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}_2" do
+        assert_equal [:als1_foo, :als2_foo, :als3_foo], reciever.public_send(callee, 'foo')
+        assert_equal [:als1_bar], reciever.public_send(callee, 'bar')
+        assert_raises NameError do
+          reciever.public_send(callee, 'xyz')
+        end
+      end
+    end
+  end
+
+end

data/test/{test_striuct-subclass-instance-accessor.rb → test_subc-i-accessor.rb}

@@ -92,8 +92,9 @@ class Test_Striuct_Subclass_Instance_Accsessor < 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})
+    conflict_management :struct do
+      member :lambda, OR(->v{v % 3 == 2}, ->v{v.kind_of? Float})
+    end
   end
   
   def setup

data/test/test_subc-i-assign.rb

@@ -0,0 +1,49 @@
+require_relative 'helper'
+
+class Test_Striuct_Subclass_Instance_Assign < Test::Unit::TestCase
+
+  Sth = Striuct.new do
+    member :foo
+  end  
+
+  [:unassign, :delete_at].each do |callee|
+    define_method :"test_#{callee}" do
+      sth = Sth.new
+      assert_equal false, sth.assign?(:foo)
+      sth.foo = nil
+      assert_equal true, sth.assign?(:foo)
+      sth.public_send callee, :foo
+      assert_equal false, sth.assign?(:foo)
+      sth.foo = nil
+      assert_equal true, sth.assign?(:foo)
+      sth.public_send callee, 0
+      assert_equal false, sth.assign?(:foo)
+      
+      assert_raises KeyError do
+        sth.public_send callee, :var
+      end
+      
+      assert_raises KeyError do
+        sth.public_send callee, 1
+      end
+    end
+  end
+  
+  def test_empty?
+    cls = Striuct.new :foo, :bar
+    sth = cls.new
+    
+    assert_same true, sth.empty?
+    
+    sth.foo = nil
+    assert_same false, sth.empty?
+    sth.bar = true
+    assert_same false, sth.empty?
+    sth.unassign :foo
+    assert_same false, sth.empty?
+    sth.unassign :bar
+
+    assert_same true, sth.empty?
+  end
+
+end

data/test/test_subc-i-cast.rb

@@ -0,0 +1,27 @@
+require_relative 'helper'
+
+class Test_Striuct_Subclass_Instance_Cast < Test::Unit::TestCase
+
+  Sth = Striuct.new :foo, :bar, :hoge
+  
+  def test_to_h
+    sth = Sth.new
+    assert_equal({foo: nil, bar: nil, hoge: nil}, sth.to_h)
+    assert_equal({foo: nil, bar: nil, hoge: nil}, sth.to_h(true))
+    assert_equal({}, sth.to_h(false))
+
+    sth.bar = :BAR
+    assert_equal({foo: nil, bar: :BAR, hoge: nil}, sth.to_h)
+    assert_equal({foo: nil, bar: :BAR, hoge: nil}, sth.to_h(true))
+    assert_equal({bar: :BAR}, sth.to_h(false))
+  end
+
+  def test_to_a
+    sth = Sth.new
+    assert_equal([nil, nil, nil], sth.to_a)
+
+    sth.bar = :BAR
+    assert_equal([nil, :BAR, nil], sth.to_a)
+  end
+
+end

data/test/{test_striuct-subclass-instance-default_value.rb → test_subc-i-default_value.rb}

@@ -107,7 +107,7 @@ class Test_Striuct_Subclass_Instance_DefaultValue_Under_MemberMacro < Test::Unit
     seef = nil
     klass = Striuct.define do
       
-      scope.assert_raises ArgumentError do
+      scope.assert_raises OptionalArgument::KeyConflictError do
         member :lank, Integer, default: '10', default_proc: ->own,name{rand}
       end
       
@@ -126,4 +126,4 @@ class Test_Striuct_Subclass_Instance_DefaultValue_Under_MemberMacro < Test::Unit
     assert_equal seef, klass.new
   end
 
-end
+end

data/test/{test_striuct-subclass-instance-hashlike.rb → test_subc-i-hashlike.rb}

@@ -3,15 +3,6 @@ require_relative 'helper'
 class Test_Striuct_Subclass_Instance_HashLike < 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]

data/test/{test_striuct-subclass-instance-lock.rb → test_subc-i-lock.rb}

@@ -7,11 +7,11 @@ class Test_Striuct_Subclass_Instance_Lock < Test::Unit::TestCase
   
   def test_lock
     sth = Sth.new
-    assert_equal false, sth.lock?(:foo)
-    assert_equal false, sth.lock?(:bar)
+    assert_equal false, sth.locked?(:foo)
+    assert_equal false, sth.locked?(:bar)
     assert_equal false, sth.secure?
     sth.lock :bar
-    assert_equal true, sth.lock?(:bar)
+    assert_equal true, sth.locked?(:bar)
     assert_equal false, sth.secure?
   
     assert_raises RuntimeError do
@@ -20,15 +20,15 @@ class Test_Striuct_Subclass_Instance_Lock < Test::Unit::TestCase
    
     sth.__send__ :unlock, :bar
     
-    assert_equal false, sth.lock?(:bar)
+    assert_equal false, sth.locked?(: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?
+    sth.lock_all
+    assert_equal true, sth.locked?(:foo)
+    assert_equal true, sth.locked?(:bar)
+    assert_equal true, sth.all_locked?
     
     assert_raises RuntimeError do
       sth.foo = 1

data/test/{test_striuct-subclass-instance-to_s_family.rb → test_subc-i-to_s_family.rb}

@@ -18,7 +18,7 @@ class Test_Striuct_Subclass_Instance_to_s_Family < Test::Unit::TestCase
 
   def test_inspect
     user = User.new 9999, 'taro', 'yamada', 'Tokyo Japan', 30
-    assert_equal %q!#<struct' Test_Striuct_Subclass_Instance_to_s_Family::User strict?:true id=9999(valid?:true, lock?:false), last_name="taro"(valid?:true, lock?:false), family_name="yamada"(valid?:true, lock?:false), address="Tokyo Japan"(valid?:true, lock?:false), age=30(valid?:true, lock?:false)>!,
+    assert_equal %q!#<struct' Test_Striuct_Subclass_Instance_to_s_Family::User strict?:true id=9999(valid?:true, locked?:false), last_name="taro"(valid?:true, locked?:false), family_name="yamada"(valid?:true, locked?:false), address="Tokyo Japan"(valid?:true, locked?:false), age=30(valid?:true, locked?:false)>!,
                  user.inspect
   end