striuct 0.3.0 → 0.3.1

data/test/test_striuct_define.rb

@@ -0,0 +1,19 @@
+require_relative 'helper'
+
+class TestStriuctDefine < Test::Unit::TestCase
+
+  def test_define
+    assert_raises RuntimeError do
+      Striuct.define do
+      end
+    end
+    
+    klass = Striuct.define do
+      member :foo
+    end
+
+    assert_equal true, klass.closed?
+  end
+
+end
+

data/test/test_striuct_subclass_adjuster.rb

@@ -0,0 +1,95 @@
+require_relative 'helper'
+
+class TestStriuctAdjusterOld < Test::Unit::TestCase
+
+  Sth = Striuct.new do
+    member :age, Numeric, &->arg{Integer arg}
+  end
+  
+  def setup
+    @sth = Sth.new
+    assert_same nil, @sth.age
+  end
+  
+  def test_procedure
+    @sth.age = 10
+    assert_same 10, @sth.age
+    @sth.age = 10.0
+    assert_same 10, @sth.age
+
+    assert_raises Validation::UnmanagebleError do
+      @sth.age = '10.0'
+    end
+    
+    @sth.age = '10'
+    assert_same 10, @sth.age
+  end
+
+end
+
+
+class TestStriuctAdjuster < Test::Unit::TestCase
+
+  class MyClass
+    def self.parse(v)
+      raise unless /\A[a-z]+\z/ =~ v
+      new
+    end
+  end
+  
+  Sth = Striuct.define do
+    member :chomped, AND(Symbol, /[^\n]\z/), &WHEN(String, ->v{v.chomp.to_sym})
+    member :no_reduced, Symbol, &->v{v.to_sym}
+    member :reduced, Symbol, &INJECT(->v{v.to_s}, ->v{v.to_sym})
+    member :integer, Integer, &PARSE(Integer)
+    member :myobj, ->v{v.instance_of? MyClass}, &PARSE(MyClass)
+  end
+  
+  def test_WHEN
+    sth = Sth.new
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.chomped = :"a\n"
+    end
+    
+    sth.chomped = "a\n"
+    
+    assert_equal :a, sth.chomped
+    
+    sth.chomped = :b
+    assert_equal :b, sth.chomped
+  end
+
+  def test_INJECT
+    sth = Sth.new
+    
+    assert_raises Validation::UnmanagebleError do
+      sth.no_reduced = 1
+    end
+    
+    sth.reduced = 1
+    
+    assert_equal :'1', sth.reduced
+  end
+  
+  def test_PARSE
+    sth = Sth.new
+    
+    assert_raises Validation::UnmanagebleError do
+      sth.integer = '1.0'
+    end
+    
+    sth.integer = '1'
+    
+    assert_equal 1, sth.integer
+    
+    assert_raises Validation::UnmanagebleError do
+      sth.myobj = '1'
+    end
+    
+    sth.myobj = 'a'
+    
+    assert_kind_of MyClass, sth.myobj
+  end
+
+end

data/test/test_striuct_subclass_alias_member.rb

@@ -0,0 +1,54 @@
+require_relative 'helper'
+
+class TestStriuctAliasMember < Test::Unit::TestCase
+
+  class Sth < Striuct.new
+    member :foo, String
+    
+    member :bar, Integer do |v|
+      v
+    end
+    
+    member :hoge, Symbol
+    default :hoge, :'Z'
+    alias_member :abc, :bar
+    default :abc, 8
+  end
+
+  def test_alias_member
+    sth = Sth.new 'A'
+    assert_equal [:foo, :bar, :hoge], sth.members
+    assert_equal [:foo, :bar, :hoge], sth.autonyms
+    assert_equal({abc: :bar}, sth.aliases)
+    assert_equal [:foo, :bar, :hoge, :abc], sth.all_members
+
+    assert_equal 8, sth[:abc]
+    flavor = Sth.__send__(:flavor_for, :abc)
+    assert_kind_of Proc, flavor
+    assert_same flavor, Sth.__send__(:flavor_for, :bar)
+    assert_equal 8, sth.abc
+    sth.abc = 5
+    assert_equal 5, sth.bar
+    sth[:abc] = 6
+    assert_equal 6, sth.bar
+    
+    assert_raises Validation::InvalidWritingError do
+      sth[:abc] = 'a'
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.abc = 'a'
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.bar = 'a'
+    end
+    
+    assert_raises ArgumentError do
+      Sth.class_eval do
+        member :abc
+      end
+    end
+  end
+
+end

data/test/test_striuct_subclass_assign.rb

@@ -0,0 +1,30 @@
+require_relative 'helper'
+
+class TestStriuctAssign < Test::Unit::TestCase
+
+  Sth = Striuct.new do
+    member :foo
+  end  
+
+  def test_unassign
+    sth = Sth.new
+    assert_equal false, sth.assign?(:foo)
+    sth.foo = nil
+    assert_equal true, sth.assign?(:foo)
+    sth.unassign :foo
+    assert_equal false, sth.assign?(:foo)
+    sth.foo = nil
+    assert_equal true, sth.assign?(:foo)
+    sth.clear_at 0
+    assert_equal false, sth.assign?(:foo)
+    
+    assert_raises NameError do
+      sth.unassign :var
+    end
+    
+    assert_raises IndexError do
+      sth.unassign 1
+    end
+  end
+
+end

data/test/test_striuct_subclass_classlock.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+class TestStriuctClassLock < Test::Unit::TestCase
+
+  Sth = Striuct.new do
+    member :foo
+  end
+
+  def test_class_lock
+    sth = Sth.new
+
+    assert_equal true, sth.member?(:foo)
+
+    Sth.class_eval do
+      member :bar
+    end
+
+    assert_equal true, sth.member?(:bar)
+    assert_equal [:foo, :bar], sth.members
+    
+    assert_equal false, Sth.closed?
+    
+    Sth.__send__ :close
+    
+    assert_equal true, Sth.closed?
+   
+    assert_raises RuntimeError do
+      Sth.class_eval do
+        member :var2
+      end
+    end
+   
+    assert_equal false, sth.member?(:var2)
+  end
+
+end

data/test/test_striuct_subclass_classmethods.rb

@@ -0,0 +1,87 @@
+require_relative 'helper'
+
+class TestStriuctSubclassClassMethods < 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
+  
+  User2 = Striuct.define do
+    member :name, AND(String, NOT(''))
+    member :age, Fixnum
+  end
+  
+  def test_builder
+    klass = Striuct.new
+    assert_kind_of Striuct, klass.new
+    
+    klass = Striuct.new :name, :age
+    
+    assert_equal klass.members, [:name, :age]
+    
+    klass = Striuct.new :foo do
+      member :var
+    end
+    
+    assert_equal klass.members, [:foo, :var]
+    assert_equal User.members, [:id, :last_name, :family_name, :address, :age]
+  end
+
+  def test_define
+    user = User2.define{|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    
+    assert_raises RuntimeError do
+      user.age = 1
+    end
+    
+    user = User2.define{|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    assert_same true, user.lock?
+    assert_same false, user.frozen?
+    
+    assert_raises RuntimeError do
+      User2.define{|r|r.age = 1}
+    end
+    
+    user = User2.define(lock: true){|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    assert_same true, user.lock?
+    user = User2.define(lock: false){|r|r.age = 1; r.name = 'a'}
+    assert_same false, user.lock?
+    assert_equal true, user.strict?
+    
+    assert_raises Validation::InvalidWritingError do
+      User2.define{|r|r.age = 1; r.name = 'a'; r.name.clear}
+    end
+    
+    user = User2.define(strict: false){|r|r.age = 1; r.name = 'a'; r.name.clear}
+    assert_equal '', user.name
+    assert_equal false, user.strict?
+  end
+  
+  def test_restrict?
+    klass = Striuct.new :foo do
+      member :var, //
+      member :hoge
+      member :moge, nil
+    end
+    
+    assert_equal false, klass.restrict?(:foo)
+    assert_equal true, klass.restrict?(:var)
+    assert_equal false, klass.restrict?(:hoge)
+    assert_equal true, klass.restrict?(:moge)
+  end
+  
+  def test_add_members
+    klass = Striuct.new :foo do
+      add_members :aaa, 'bbb', :ccc
+    end
+    
+    assert_equal [:foo, :aaa, :bbb, :ccc], klass.members
+  end
+end  

data/test/test_striuct_subclass_cloning.rb

@@ -0,0 +1,36 @@
+$VERBOSE = true
+require_relative 'helper'
+
+class TestStriuctCloning < Test::Unit::TestCase
+
+  class Sth < Striuct.new
+    member :sth
+  end
+  
+  def setup
+    @sth = Sth.new
+  end
+  
+  def test_clone
+    sth2 = @sth.dup
+    @sth.sth = 1
+    assert_equal false, (@sth.sth == sth2.sth)
+    
+    sth2 = @sth.clone
+    @sth.sth = 2
+    assert_equal false, (@sth.sth == sth2.sth)
+  end
+  
+  def test_class_dup
+    klass = Sth.dup
+    Sth.__send__ :member, :dummy1
+    assert_equal false, klass.member?(:dummy1)
+  end
+  
+  def test_class_clone
+    klass = Sth.clone
+    Sth.__send__ :member, :dummy2
+    assert_equal false, klass.member?(:dummy2)
+  end
+
+end

data/test/test_striuct_subclass_default_value.rb

@@ -0,0 +1,129 @@
+require_relative 'helper'
+
+class TestStriuctDefaultValue < Test::Unit::TestCase
+
+  Sth = Striuct.new do
+    member :lank, OR(Bignum, Fixnum)
+    default :lank, 1
+  end
+  
+  def test_default
+    sth = Sth.new 2
+    assert_equal 2, sth.lank
+    sth = Sth.new
+    assert_equal 1, sth.lank
+    assert_equal true, sth.default?(:lank)
+    sth.lank = 2
+    assert_equal false, sth.default?(:lank)
+  end
+  
+  def test_define_default
+    assert_raises NameError do
+      Sth.class_eval do
+        default :anything, 10
+      end
+    end
+    
+    klass = Striuct.define do
+      member :lank2, Integer
+      default :lank2, '10'
+    end
+
+    assert_raises Validation::InvalidWritingError do
+      klass.new
+    end
+    
+    scope = self
+    seef = nil
+    klass = Striuct.define do
+      member :lank, Integer
+
+      scope.assert_raises ArgumentError do
+        default :lank, &->own, name, exess{rand}
+      end
+
+      scope.assert_raises ArgumentError do
+        default :lank, '10', &->own, name{rand}
+      end
+      
+      scope.assert_raises ArgumentError do
+        default :lank, '10', &->own{rand}
+      end
+      
+      scope.assert_raises ArgumentError do
+        default :lank, '10', &->{rand}
+      end
+      
+      default :lank, &->own, name{(seef = own); rand}
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      klass.new
+    end
+    
+    klass = Striuct.define do
+      member :lank, Integer      
+      default :lank, &->own, name{(seef = own); 10 - name.length}
+    end
+    
+    assert_equal 6, klass.new.lank
+    assert_equal seef, klass.new
+  end
+
+end
+
+class TestStriuctDefaultValueinMemberMacro < Test::Unit::TestCase
+
+  Sth = Striuct.new do
+    member :lank, OR(Bignum, Fixnum), default: 1
+  end
+  
+  def test_default
+    sth = Sth.new 2
+    assert_equal 2, sth.lank
+    sth = Sth.new
+    assert_equal 1, sth.lank
+    assert_equal true, sth.default?(:lank)
+    sth.lank = 2
+    assert_equal false, sth.default?(:lank)
+  end
+  
+  def test_define_default
+    assert_raises NameError do
+      Sth.class_eval do
+        default :anything, 10
+      end
+    end
+    
+    klass = Striuct.define do
+      member :lank2, Integer, default: '10'
+    end
+
+    assert_raises Validation::InvalidWritingError do
+      klass.new
+    end
+    
+    scope = self
+    seef = nil
+    klass = Striuct.define do
+      
+      scope.assert_raises ArgumentError do
+        member :lank, Integer, default: '10', default_proc: ->own,name{rand}
+      end
+      
+      member :lank, Integer, default_proc: ->own,name{(seef = own); rand}
+    end
+    
+    assert_raises Validation::InvalidWritingError do
+      klass.new
+    end
+    
+    klass = Striuct.define do
+      member :lank, Integer, default_proc: ->own,name{(seef = own); 10 - name.length}
+    end
+    
+    assert_equal 6, klass.new.lank
+    assert_equal seef, klass.new
+  end
+
+end

data/test/test_striuct_subclass_for_pairs.rb

@@ -0,0 +1,13 @@
+require_relative 'helper'
+
+class TestStriuctForPairs < Test::Unit::TestCase
+
+  Sth = Striuct.new :foo, :bar, :hoge
+  
+  def test_for_pairs
+    sth = Sth[hoge: 7, foo: 8]
+   
+    assert_equal [8, nil, 7], sth.values
+  end
+
+end

data/test/test_striuct_subclass_freeze.rb

@@ -0,0 +1,19 @@
+require_relative 'helper'
+
+class TestStriuctFreeze < 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_striuct_subclass_functional_condition.rb

@@ -0,0 +1,51 @@
+require_relative 'helper'
+
+class TestStriuctFunctionalCondition < 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

data/test/test_striuct_subclass_getter_validation.rb

@@ -0,0 +1,33 @@
+require_relative 'helper'
+
+class TestGetterValidation < Test::Unit::TestCase
+
+  Sth = Striuct.define do
+    member :plus_getter, /./, getter_validation: true
+    member :only_getter, /./, getter_validation: true,
+                              setter_validation: false
+  end
+  
+  def test_getter_validation
+    sth = Sth.new
+    
+    assert_raises Validation::InvalidWritingError do
+      sth.plus_getter = ''
+    end
+    
+    sth.plus_getter = 'abc'
+    assert_equal 'abc', sth.plus_getter
+    sth.plus_getter.clear
+    
+    assert_raises Validation::InvalidReadingError do
+      sth.plus_getter
+    end
+    
+    sth.only_getter = ''
+    
+    assert_raises Validation::InvalidReadingError do
+      sth.only_getter
+    end
+  end
+
+end