striuct 0.6.1 → 0.7.0

data/test/test_subc-f-to_struct.rb

@@ -1,61 +0,0 @@
-require_relative 'helper'
-
-TopLevelSthForTest_to_Struct = Striuct.define do
-  member :name, String
-  member :age, Integer
-end
-
-class Test_Striuct_Subclass_to_Struct < Test::Unit::TestCase
-
-  NestedSth = Striuct.define do
-    member :name, String
-    member :age, Integer
-  end
-  
-  def teardown
-    constants = Striuct::Structs.constants
-    constants.each do |cons|
-      Striuct::Structs.__send__ :remove_const, cons
-    end
-  end
-  
-  alias_method :setup, :teardown
-  
-  def test_raise
-    assert_raises RuntimeError do
-      Striuct.new.new.to_struct
-    end
-  end
-  
-  def test_noname
-    assert_same 0, Striuct::Structs.constants.length
-    struct_cls = Striuct.new(:a, :b, :c).new.to_struct
-    assert_equal [:a, :b, :c], struct_cls.members
-    assert_same 0, Striuct::Structs.constants.length
-  end
-  
-  def test_to_nested_struct
-    assert_same 0, Striuct::Structs.constants.length
-    struct_cls = NestedSth.to_struct_class
-    assert_same Struct, struct_cls.superclass
-    assert_equal [:name, :age], struct_cls.members
-    assert_same 1, Striuct::Structs.constants.length
-    assert_equal 'Striuct::Structs::NestedSth', struct_cls.name
-    assert_same struct_cls, NestedSth.to_struct_class
-    assert_kind_of Struct, NestedSth.new.to_struct
-    assert_instance_of Striuct::Structs::NestedSth, NestedSth.new.to_struct
-  end
-  
-  def test_to_toplevel_struct
-    assert_same 0, Striuct::Structs.constants.length
-    struct_cls = TopLevelSthForTest_to_Struct.to_struct_class
-    assert_same Struct, struct_cls.superclass
-    assert_equal [:name, :age], struct_cls.members
-    assert_same 1, Striuct::Structs.constants.length
-    assert_equal 'Striuct::Structs::TopLevelSthForTest_to_Struct', struct_cls.name
-    assert_same struct_cls, TopLevelSthForTest_to_Struct.to_struct_class
-    assert_kind_of Struct, TopLevelSthForTest_to_Struct.new.to_struct
-    assert_instance_of Striuct::Structs::TopLevelSthForTest_to_Struct, TopLevelSthForTest_to_Struct.new.to_struct
-  end
-
-end

data/test/test_subc-f-validation_util.rb

@@ -1,59 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Validation_Util < Test::Unit::TestCase
-
-  ALWAYS_OCCUR_ERROR = ->_{raise Exception}
-  peep = nil
-  
-  Foo = Striuct.define do
-    member :foo, nil
-    member :bar, ALWAYS_OCCUR_ERROR
-    member :hoge
-    peep = AND(String, /./)
-    member :some_str, peep
-  end
-
-  SOME_STR = peep
-
-  def test_predicate_restrict?
-    assert_same true, Foo.restrict?(:foo)
-    assert_same true, Foo.restrict?(:bar)
-    assert_same false, Foo.restrict?(:hoge)
-    assert_same true, Foo.new.restrict?(:foo)
-    assert_same true, Foo.new.restrict?(:bar)
-    assert_same false, Foo.new.restrict?(:hoge)
-  end
-
-  def test_predicate_with_condition?
-    assert_same true, Foo.with_condition?(:foo)
-    assert_same true, Foo.with_condition?(:bar)
-    assert_same false, Foo.with_condition?(:hoge)
-    assert_same true, Foo.new.with_condition?(:foo)
-    assert_same true, Foo.new.with_condition?(:bar)
-    assert_same false, Foo.new.with_condition?(:hoge)
-  end
-
-  def test_predicate_instance_sufficient?
-    foo = Foo.new
-    assert_same true, foo.sufficient?(:foo)
-    assert_same false, foo.sufficient?(:bar)
-    assert_same true, foo.sufficient?(:hoge)
-    assert_same false, foo.sufficient?(:some_str)
-    foo.some_str = ':)'
-    assert_same true, foo.sufficient?(:some_str)
-    foo.some_str.clear
-    assert_same false, foo.sufficient?(:some_str)
-  end
-
-  def test_condition_for
-    foo = Foo.new
-    assert_same nil, foo.condition_for(:foo)
-    assert_same ALWAYS_OCCUR_ERROR, foo.condition_for(:bar)
-    assert_raises KeyError do
-      foo.condition_for(:hoge)
-    end
-    assert_same SOME_STR, foo.condition_for(:some_str)
-  end
-
-
-end

data/test/test_subc-f_debug.rb

@@ -1,39 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Debug < Test::Unit::TestCase
-
-  Subclass = Striuct.define do
-    member :foo
-    member :bar
-    alias_member :als_foo, :foo
-  end.freeze
-
-  INSTANCE = Subclass.new.freeze
-  
-  TYPE_PAIRS = {
-    Class: Subclass,
-    Instance: INSTANCE
-  }.freeze
-
-  [:attributes].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_instance_of Hash, ret
-        assert_equal [:autonyms, :aliases, :conflict_management_level, :attributes_each_autonym], ret.keys
-        assert_equal Subclass.autonyms, ret.fetch(:autonyms)
-        assert_equal Subclass.aliases, ret.fetch(:aliases)
-        assert_equal Subclass.conflict_management_level, ret.fetch(:conflict_management_level)
-        assert_equal Subclass.instance_variable_get(:@attributes), ret.fetch(:attributes_each_autonym)
-        
-        10.times do
-          ret2 = reciever.public_send(callee)
-          assert_not_same ret, ret2
-          assert_equal ret, ret2
-        end
-      end
-    end
-  end
-
-end

data/test/test_subc-f_name.rb

@@ -1,525 +0,0 @@
-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_equal 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