striuct 0.4.4 → 0.7.0

data/test/test_subc-i-freeze.rb

@@ -1,19 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance__Freeze < Test::Unit::TestCase
-
-  Sth = Striuct.new :foo
-  
-  def test_freeze
-    sth = Sth.new
-    sth.freeze
-    
-    assert_raises RuntimeError do
-     sth.foo = 8
-    end
-   
-    assert_equal true, sth.frozen?
-  end
-
-end
-

data/test/test_subc-i-hashlike.rb

@@ -1,144 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_HashLike < Test::Unit::TestCase
-
-  Sth = Striuct.new :foo, :bar, :hoge
-  
-  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_subc-i-keyvalidatable.rb

@@ -1,25 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_KeyVallidatable < Test::Unit::TestCase
-
-  Sth = Striuct.new :foo, :bar
-  
-  def test_valid_keys?
-    sth = Sth.new
-    assert(sth.valid_keys?(must: [:foo, :bar]))
-    assert(sth.valid_keys?(let: [:foo, :bar]))
-    assert(sth.valid_keys?(must: [:foo], let: [:bar]))
-    assert(sth.valid_keys?(let: [:foo, :bar, :hoge]))
-    assert_same(false, sth.valid_keys?(must: [:foo, :bar, :hoge]))
-  end
-  
-  def test_valid_autonyms?
-    sth = Sth.new
-    assert(sth.valid_autonyms?(must: [:foo, :bar]))
-    assert(sth.valid_autonyms?(let: [:foo, :bar]))
-    assert(sth.valid_autonyms?(must: [:foo], let: [:bar]))
-    assert(sth.valid_autonyms?(let: [:foo, :bar, :hoge]))
-    assert_same(false, sth.valid_autonyms?(must: [:foo, :bar, :hoge]))
-  end
-  
-end

data/test/test_subc-i-lock.rb

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

data/test/test_subc-i-must.rb

@@ -1,30 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Must < Test::Unit::TestCase
-
-  Sth = Striuct.define do
-    member :foo, ANYTHING?, must: false
-    member :bar, ANYTHING?, must: true
-    member :baz
-  end
-  
-  def test_must
-    assert_raises(Striuct::InvalidOperationError) do
-      Sth.new :foo
-    end
-
-    assert_raises(Striuct::InvalidOperationError) do
-      Sth.new foo: :foo, baz: :baz
-    end
-
-    sth = Sth.new :foo, :bar, :baz
-    assert_instance_of(Sth, sth)
-
-    assert_raises(Striuct::InvalidOperationError) do
-      sth.unassign :bar
-    end
-
-    assert_nil(sth.bar = nil)
-  end
-
-end

data/test/test_subc-i-to_s_family.rb

@@ -1,26 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_to_s_Family < Test::Unit::TestCase
-
-  class User < Striuct.new
-    member :id, Integer, must: true
-    member :name, /\w+/
-  end
-
-  def setup
-    @sth = User.new 9999, 'taro'
-    @sth.lock(:name)
-    @sth.name.clear
-  end
-
-  def test_to_s
-    assert_equal %q!#<struct' Test_Striuct_Subclass_Instance_to_s_Family::User id=9999, name="">!,
-                 @sth.to_s
-  end
-
-  def test_inspect
-    assert_equal %q!#<struct' Test_Striuct_Subclass_Instance_to_s_Family::User id=9999(must), name=""(invalid, locked)>!,
-                 @sth.inspect
-  end
-
-end

data/test/test_subc-i-validation_inference.rb

@@ -1,51 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_Inference < Test::Unit::TestCase
-
-  def test_inference
-    klass = Striuct.define do
-      member :n, Numeric, inference: true
-      member :m, BasicObject, 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_subc-i-validation_specific_conditions.rb

@@ -1,297 +0,0 @@
-require_relative 'helper'
-
-class Test_Striuct_Subclass_Instance_SpecificConditions < Test::Unit::TestCase
-
-  Sth = Striuct.define do
-    member :list_only_int, GENERICS(Integer)
-    member :true_or_false, BOOL?
-    member :like_str, STRINGABLE?
-    member :has_foo, CAN(:foo)
-    member :has_foo_and_bar, CAN(:foo, :bar)
-    member :one_of_member, MEMBER_OF([1, 3])
-    member :has_ignore, AND(1..5, 3..10)
-    member :nand, NAND(1..5, 3..10)
-    member :all_pass, OR(1..5, 3..10)
-    member :catch_error, CATCH(NoMethodError){|v|v.no_name!}
-    member :no_exception, QUIET(->v{v.class})
-    member :not_integer, NOT(Integer)
-  end
-
-  def test_not
-    sth = Sth.new
-    
-    obj = Object.new
-    
-    sth.not_integer = obj
-    assert_same obj, sth.not_integer
-
-    assert_raises Validation::InvalidWritingError do
-      sth.not_integer = 1
-    end
-  end
-
-
-  def test_still
-    sth = Sth.new
-    
-    obj = Object.new
-    
-    sth.no_exception = obj
-    assert_same obj, sth.no_exception
-    sth.no_exception = false
-
-    obj.singleton_class.class_eval do
-      undef_method :class
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      sth.no_exception = obj
-    end
-  end
-
-  def test_catch
-    sth = Sth.new
-    
-    obj = Object.new
-    
-    sth.catch_error = obj
-    assert_same obj, sth.catch_error
-    sth.catch_error = false
-
-    obj.singleton_class.class_eval do
-      def no_name!
-      end
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      sth.catch_error = obj
-    end
-  end
-
-  def test_or
-    sth = Sth.new
-
-    assert_raises Validation::InvalidWritingError do
-      sth.all_pass = 11
-    end
-    
-    sth.all_pass = 1
-    assert_equal 1, sth.all_pass
-    sth.all_pass = 4
-    assert_equal 4, sth.all_pass
-    assert_equal true, sth.valid?(:all_pass)
-  end
-
-  def test_and
-    sth = Sth.new
-
-    assert_raises Validation::InvalidWritingError do
-      sth.has_ignore = 1
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      sth.has_ignore= 2
-    end
-  
-    sth.has_ignore = 3
-    assert_equal 3, sth.has_ignore
-    assert_equal true, sth.valid?(:has_ignore)
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.has_ignore = []
-    end
-  end
-
-  def test_nand
-    sth = Sth.new
-
-    assert_raises Validation::InvalidWritingError do
-      sth.nand = 4
-    end
-
-    assert_raises Validation::InvalidWritingError do
-      sth.nand = 4.5
-    end
-  
-    sth.nand = 2
-    assert_equal 2, sth.nand
-    assert_equal true, sth.valid?(:nand)
-    sth.nand = []
-    assert_equal [], sth.nand
-  end
-
-  def test_member_of
-    sth = Sth.new
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.one_of_member = 4
-    end
-  
-    sth.one_of_member = 3
-    assert_equal 3, sth.one_of_member
-    assert_equal true, sth.valid?(:one_of_member)
-  end
-  
-  def test_generics
-    sth = Sth.new
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.list_only_int = [1, '2']
-    end
-  
-    sth.list_only_int = [1, 2]
-    assert_equal [1, 2], sth.list_only_int
-    assert_equal true, sth.valid?(:list_only_int)
-    sth.list_only_int = []
-    assert_equal [], sth.list_only_int
-    assert_equal true, sth.valid?(:list_only_int)
-    sth.list_only_int << '2'
-    assert_equal false, sth.valid?(:list_only_int)
-  end
-  
-  def test_boolean
-    sth = Sth.new
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.true_or_false = nil
-    end
-    
-    assert_equal false, sth.valid?(:true_or_false)
-  
-    sth.true_or_false = true
-    assert_equal true, sth.true_or_false
-    assert_equal true, sth.valid?(:true_or_false)
-    sth.true_or_false = false
-    assert_equal false, sth.true_or_false
-    assert_equal true, sth.valid?(:true_or_false)
-  end
-  
-  def test_stringable
-    sth = Sth.new
-    obj = Object.new
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.like_str = obj
-    end
-  
-    sth.like_str = 'str'
-    assert_equal true, sth.valid?(:like_str)
-    sth.like_str = :sym
-    assert_equal true, sth.valid?(:like_str)
-    
-    obj.singleton_class.class_eval do
-      def to_str
-      end
-    end
-    
-    sth.like_str = obj
-    assert_equal true, sth.valid?(:like_str)
-  end
-
-  def test_responsible_arg1
-    sth = Sth.new
-    obj = Object.new
-    
-    raise if obj.respond_to? :foo
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.has_foo = obj
-    end
-    
-    obj.singleton_class.class_eval do
-      def foo
-      end
-    end
-    
-    raise unless obj.respond_to? :foo
-    
-    sth.has_foo = obj
-    assert_equal obj, sth.has_foo
-    assert_equal true, sth.valid?(:has_foo)
-  end
-
-  def test_responsible_arg2
-    sth = Sth.new
-    obj = Object.new
-    
-    raise if obj.respond_to? :foo
-    raise if obj.respond_to? :bar
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.has_foo_and_bar = obj
-    end
-    
-    obj.singleton_class.class_eval do
-      def foo
-      end
-    end
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.has_foo_and_bar = obj
-    end
-    
-    raise unless obj.respond_to? :foo
-    
-    obj.singleton_class.class_eval do
-      def bar
-      end
-    end
-    
-    raise unless obj.respond_to? :bar
-    
-    sth.has_foo_and_bar = obj
-    assert_equal obj, sth.has_foo_and_bar
-    assert_equal true, sth.valid?(:has_foo_and_bar)
-  end
-
-end
-
-class Test_Striuct_Subclass_Instance_SpecificConditions_FunctionalCondition < Test::Unit::TestCase
-
-  Sthlambda = Striuct.new do
-    member :lank, ->lank{lanks.include? lank}
-    member :lanks
-    default :lanks, 1..30
-  end
-  
-  def test_lambda
-    sth = Sthlambda.new
-    sth.lank = 2
-    assert_equal 2, sth.lank
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.lank = 31
-    end
-  end
-  
-  max = 9
-
-  SthProc = Striuct.new do
-    member :lank, Proc.new{|n|(3..max) === n}
-  end
-
-  def test_Proc
-    sth = SthProc.new
-    sth.lank = 8
-    assert_equal 8, sth.lank
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.lank = 2
-    end
-  end
-  
-  SthMethod = Striuct.new do
-    member :lank, 7.method(:<)
-  end
-  
-  def test_Method
-    sth = SthMethod.new
-    sth.lank = 8
-    assert_equal 8, sth.lank
-    
-    assert_raises Validation::InvalidWritingError do
-      sth.lank = 6
-    end
-  end
-
-end