striuct 0.3.5.1 → 0.4.0

data/lib/striuct/instancemethods/object.rb

@@ -5,13 +5,13 @@ class Striuct; module InstanceMethods
   def initialize(*values)
     @db, @locks = {}, {}
     replace_values(*values)
-    excess = _autonyms.last(size - values.size)
-    set_defaults(*excess)
+    excess_autonyms = _autonyms.last(size - values.size)
+    _set_defaults(*excess_autonyms)
   end
 
   # @return [self]
   def freeze
-    [@db, @locks].each(&:freeze)
+    @db.freeze; @locks.freeze
     super
   end
   
@@ -23,27 +23,4 @@ class Striuct; module InstanceMethods
 
   # @endgroup
 
-  # @group Default Value
-
-  # @return [self]
-  def set_defaults(*target_autonyms)
-    target_autonyms.each do |autonym|
-      if has_default? autonym
-        default = default_value_for autonym
-        self[autonym] = (
-          if default_type_for(autonym) == :lazy
-            args = [self, autonym][0, default.arity]
-            default.call(*args)
-          else
-            default
-          end
-        )
-      end
-    end
-    
-    self
-  end
-
-  # @endgroup
-
 end; end

data/lib/striuct/instancemethods/requirements.rb

@@ -1,6 +1,19 @@
+require 'forwardable'
+require 'keyvalidatable'
+
+class Striuct; module InstanceMethods
+
+  extend Forwardable
+
+  # hide Forwardable's public/protected class_macro
+  private_class_method(*Forwardable.instance_methods)
+
+  include KeyValidatable
+
+end; end
+
 require_relative 'delegate_class_methods'
 require_relative 'keyvalidatable'
-require_relative 'inner_accessor'
 require_relative 'object'
 require_relative 'compare'
 require_relative 'to_s'
@@ -9,7 +22,8 @@ require_relative 'cast'
 require_relative 'default'
 require_relative 'enum'
 require_relative 'hashy'
-require_relative 'subscript'
+require_relative 'getter'
+require_relative 'setter'
 require_relative 'assign'
 require_relative 'lock'
 require_relative 'validation'

data/lib/striuct/instancemethods/safety.rb

@@ -4,7 +4,7 @@ class Striuct; module InstanceMethods
   
   # freezed, fixed familar members, all members passed any condition
   def secure?
-    (frozen? || lock?) && self.class.closed? && strict?
+    (frozen? || all_locked?) && self.class.closed? && strict?
   end
 
   # @endgroup

data/lib/striuct/instancemethods/setter.rb

@@ -0,0 +1,58 @@
+class Striuct; module InstanceMethods
+
+  # @group Setter
+
+  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+  # @return value
+  def []=(key, value)
+    autonym = autonym_for_key key
+    _set autonym, value
+  rescue Validation::InvalidWritingError
+    $!.set_backtrace([
+      "#{$!.backtrace[-1].sub(/[^:]+\z/){''}}in `[#{key.inspect}(#{autonym})]=': #{$!.message}",
+      $!.backtrace[-1]
+    ])
+
+    raise
+  end
+
+  alias_method :assign, :[]=
+
+  private
+
+  # @param [Symbol] autonym - MUST already converted to native autonym
+  # @return value
+  def _set(autonym, value)
+    raise "can't modify frozen #{self.class}" if frozen?
+    raise "can't modify locked member #{autonym}" if locked? autonym
+
+    if with_adjuster? autonym
+      begin
+        value = instance_exec value, &adjuster_for(autonym)
+      rescue Exception
+        raise ::Validation::UnmanagebleError
+      end
+    end
+
+    if with_safety_setter?(autonym) and !accept?(autonym, value)
+      raise ::Validation::InvalidWritingError,
+            "#{value.inspect} is deficient for #{autonym} in #{self.class}"
+    end
+
+    if with_inference? autonym
+      self.class.__send__ :_found_family, autonym, value
+    end
+    
+    @db[autonym] = value
+  rescue ::Validation::InvalidError
+    unless /in \[\]=/ =~ caller[1].slice(/([^:]+)\z/)
+      $!.backtrace.delete_if{|s|/#{Regexp.escape(File.dirname __FILE__)}/ =~ s}
+      $!.backtrace.first.sub!(/([^:]+)\z/){"in `#{autonym}='"}
+    end
+  
+    raise
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/to_s.rb

@@ -6,10 +6,10 @@ class Striuct; module InstanceMethods
   def inspect
     "#<struct' #{self.class} strict?:#{strict?}".tap {|s|
       each_pair do |autonym, value|
-        suffix = (has_default?(autonym) && default?(autonym)) ? '/default' : nil
+        suffix = (with_default?(autonym) && default?(autonym)) ? '/default' : nil
         s << " #{autonym}=#{value.inspect}#{suffix}("
         s << "valid?:#{valid? autonym}, "
-        s << "lock?:#{lock? autonym}"
+        s << "locked?:#{locked? autonym}"
         s << '),'
       end
       

data/lib/striuct/instancemethods/validation.rb

@@ -2,11 +2,11 @@ class Striuct; module InstanceMethods
 
   # @group Validation
   
-  # @param [Symbol, String] name
-  # @param [Object] value - no argument and use own
-  # passed under any condition
-  def sufficient?(name, value=self[name])
-    autonym = autonym_for_name name
+  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+  # @param value
+  # true if passed under any condition
+  def accept?(key, value)
+    autonym = autonym_for_key key
     return true unless restrict? autonym
   
     begin  
@@ -15,8 +15,14 @@ class Striuct; module InstanceMethods
       false
     end
   end
-  
-  alias_method :accept?, :sufficient?
+
+  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+  # @param value - if no argument and use current assigned value
+  # true if passed under any condition
+  def sufficient?(key, value=self[key])
+    accept? key, value
+  end
+
   alias_method :valid?, :sufficient?
 
   # all members passed under any condition

data/lib/striuct/instancemethods/values.rb

@@ -2,18 +2,19 @@ class Striuct; module InstanceMethods
 
   # @group Behavior under Values
 
-  # @param [Fixnum, Range] _keys
+  # @param [Integer, #to_int, Range] _keys
   # @return [Array]
   def values_at(*_keys)
     [].tap {|r|
       _keys.each do |key|
         case key
-        when Fixnum
-          r << self[key]
+        when ->v{v.respond_to? :to_int}
+          r << fetch_by_index(key)
         when Range
-          key.each do |n|
-            raise TypeError unless n.instance_of? Fixnum
-            r << self[n]
+          key.each do |idx|
+            raise TypeError unless idx.respond_to? :to_int
+
+            r << fetch_by_index(idx)
           end
         else
           raise TypeError
@@ -29,7 +30,7 @@ class Striuct; module InstanceMethods
     end
 
     values.each_with_index do |value, index|
-      self[index] = value
+      _set autonym_for_index(index), value
     end
     
     self

data/lib/striuct/requirements.rb

@@ -1,7 +1,4 @@
-require_relative 'version'
 require_relative 'structs'
-require_relative 'attributes'
-require_relative 'hashdeepdupulicatable'
-require_relative 'classmethods'
-require_relative 'instancemethods'
+require_relative 'classmethods/requirements'
+require_relative 'instancemethods/requirements'
 require_relative 'singleton_class'

data/lib/striuct/{hashdeepdupulicatable.rb → singleton_class/hashdeepdupulicatable.rb}

@@ -1,4 +1,4 @@
-class Striuct
+class Striuct; class << self
 
   module HashDeepDupulicatable
 
@@ -18,4 +18,4 @@ class Striuct
     private_constant :HashDeepDupulicatable
   end
 
-end
+end; end

data/lib/striuct/singleton_class.rb

@@ -1,6 +1,4 @@
-require_relative 'hashdeepdupulicatable'
-require_relative 'classmethods'
-require_relative 'instancemethods'
+require_relative 'singleton_class/hashdeepdupulicatable'
 
 class Striuct
 
@@ -60,7 +58,8 @@ class Striuct
         @autonyms      = []
         @attributes    = {}.extend HashDeepDupulicatable # autonym => Attributes
         @aliases       = {} # aliased => autonym
-        @protect_level = :prevent
+        @conflict_management_level = 
+          ClassMethods::DEFAULT_CONFLICT_MANAGEMENT_LEVEL
       end
     end
 

data/striuct.gemspec

@@ -1,10 +1,10 @@
-require File.expand_path('../lib/striuct/version', __FILE__)
-
 Gem::Specification.new do |gem|
   gem.authors       = ['Kenichi Kamiya']
   gem.email         = ['kachick1+ruby@gmail.com']
   gem.summary       = %q{Struct++}
-  gem.description   = %q{Validatable, Inheritable... And more Struct++ features :)}
+  gem.description   = %q{Validatable, Inheritable, Member Aliasing,
+  Conflict Management, Default Value, Divide nil with unassign,
+  Lock setter of each member, Hash flendly API, ... And more Struct++ features :)}
   gem.homepage      = 'https://github.com/kachick/striuct'
 
   gem.files         = `git ls-files`.split($\)
@@ -12,13 +12,16 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = 'striuct'
   gem.require_paths = ['lib']
-  gem.version       = Striuct::VERSION.dup # dup for https://github.com/rubygems/rubygems/commit/48f1d869510dcd325d6566df7d0147a086905380#-P0
+  gem.version       = '0.4.0'
 
   gem.required_ruby_version = '>= 1.9.2'
 
   gem.add_runtime_dependency 'validation', '~> 0.0.3'
+  gem.add_runtime_dependency 'optionalargument', '~> 0.0.3'
   gem.add_runtime_dependency 'keyvalidatable', '~> 0.0.3'
 
   gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'bundler'
 end
 

data/test/test_sglc-constructor.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+class Test_Striuct_Constructor < Test::Unit::TestCase
+
+  def test_new
+    cls = Striuct.new
+    assert_not_instance_of Striuct, cls
+    assert_instance_of Class, cls
+    assert_kind_of Striuct, cls.new
+    
+    cls2 = Striuct.new :name, :age
+    
+    assert_equal cls2.members, [:name, :age]
+    
+    cls3 = Striuct.new :foo do
+      member :var
+    end
+    
+    assert_equal cls3.members, [:foo, :var]
+  end
+
+  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_subc-c-constructor.rb

@@ -0,0 +1,88 @@
+require_relative 'helper'
+
+class Test_Striuct_Subclass_Class_Constructor < Test::Unit::TestCase
+
+  User = Striuct.define do
+    member :name, AND(String, NOT(''))
+    member :age, Fixnum
+  end.freeze
+  
+  [:for_values, :new].each do |callee|
+    define_method :"test_subclass_#{callee}" do
+      user = User.public_send callee
+      assert_instance_of User, user
+      assert_not_kind_of Class, user
+      assert_equal [:name, :age], user.members
+      assert_equal [nil, nil], user.values
+      
+      assert_raises Validation::InvalidWritingError do
+        User.public_send callee, :SYMBOL
+      end
+      
+      assert_raises Validation::InvalidWritingError do
+        User.public_send callee, ''
+      end
+      
+      user = User.public_send callee, '.'
+      assert_instance_of User, user
+      assert_not_kind_of Class, user
+      assert_equal ['.', nil], user.values
+      
+      assert_raises Validation::InvalidWritingError do
+        User.public_send callee, '.', 1.0
+      end
+      
+      user = User.public_send callee, '.', 1
+      assert_equal ['.', 1], user.values
+    end
+  end
+  
+  def test_define
+    user = User.define{|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    
+    assert_raises RuntimeError do
+      user.age = 1
+    end
+    
+    user = User.define{|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    assert_same true, user.all_locked?
+    assert_same false, user.frozen?
+    
+    assert_raises RuntimeError do
+      User.define{|r|r.age = 1}
+    end
+    
+    user = User.define(lock: true){|r|r.age = 1; r.name = 'a'}
+    assert_same 1, user.age
+    assert_same true, user.all_locked?
+    user = User.define(lock: false){|r|r.age = 1; r.name = 'a'}
+    assert_same false, user.all_locked?
+    assert_equal true, user.strict?
+    
+    assert_raises Validation::InvalidWritingError do
+      User.define{|r|r.age = 1; r.name = 'a'; r.name.clear}
+    end
+    
+    user = User.define(strict: false){|r|r.age = 1; r.name = 'a'; r.name.clear}
+    assert_equal '', user.name
+    assert_equal false, user.strict?
+  end
+  
+  Sth = Striuct.new :foo, :bar, :hoge
+  SampleStruct = Struct.new :foo, :bar, :hoge
+  
+  def test_for_pairs_from_hash
+    sth = Sth[hoge: 7, foo: 8]
+   
+    assert_equal [8, nil, 7], sth.values
+  end
+
+  def test_for_pairs_from_struct
+    sth = Sth[SampleStruct.new 8, nil, 7]
+   
+    assert_equal [8, nil, 7], sth.values
+  end
+
+end

data/test/{test_striuct-subclass-class-safety_naming.rb → test_subc-c-safety_naming.rb}

@@ -4,21 +4,21 @@ class Test_Striuct_Subclass_Class_SafetyNaming < Test::Unit::TestCase
 
   def test_cname?
     klass = Striuct.new
-    assert_same false, klass.cname?(Object)
+    assert_same false, klass.cname?(BasicObject)
     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
+    klass.__send__ :set_conflict_management_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
+    klass.__send__ :set_conflict_management_level, :struct
     assert_same true, klass.cname?('m?')
     assert_same true, klass.cname?('__foo__')
     assert_same true, klass.cname?('a b')
@@ -62,8 +62,9 @@ class Test_Striuct_Subclass_Class_SafetyNaming < Test::Unit::TestCase
     assert_same false, klass.member?('m?')
     
     klass.class_eval do
-      protect_level :struct
-      member :'m?'
+      conflict_management :struct do
+        member :'m?'
+      end
     end
     
     assert_same true, klass.member?('m?')

data/test/test_subc-f-enum.rb

@@ -0,0 +1,139 @@
+require_relative 'helper'
+
+class Test_Striuct_Subclass_Enum < Test::Unit::TestCase
+  
+  class Subclass < Striuct
+    member :foo
+    member :bar
+
+    close_member
+  end.freeze
+
+  FOO = 'Fooo! :)'.freeze
+  BAR = 'bar :('.freeze
+  INSTANCE = Subclass.new(FOO, BAR).freeze
+  
+  TYPE_PAIRS = {
+    class: Subclass,
+    instance: INSTANCE
+  }.freeze
+
+  [:each_autonym, :each_member].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_same :foo, enum.next
+        assert_same :bar, enum.next
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+  
+  [:each_index].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_same 0, enum.next
+        assert_same 1, enum.next
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+
+  [:each_autonym_with_index, :each_member_with_index].each do |callee|
+    TYPE_PAIRS.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_equal [:foo, 0], enum.next
+        assert_equal [:bar, 1], enum.next
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+  
+  [:each_value, :each].each do |callee|
+    {instance: INSTANCE}.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_same FOO, enum.next
+        assert_same BAR, enum.next
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+
+  [:each_value_with_index, :each_with_index].each do |callee|
+    {instance: INSTANCE}.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_equal [FOO, 0], ret = enum.next
+        assert_same FOO, ret.first
+        assert_equal [BAR, 1], ret = enum.next
+        assert_same BAR, ret.first
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+
+  [:each_pair].each do |callee|
+    {instance: INSTANCE}.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_equal [:foo, FOO], ret = enum.next
+        assert_same FOO, ret.last
+        assert_equal [:bar, BAR], ret = enum.next
+        assert_same BAR, ret.last
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+
+  [:each_pair_with_index].each do |callee|
+    {instance: INSTANCE}.each_pair do |type, reciever|
+      define_method :"test_#{type}_#{callee}" do
+        assert_same(reciever, reciever.public_send(callee) {})
+        
+        enum = reciever.public_send(callee)
+        assert_instance_of Enumerator, enum
+        assert_equal [:foo, FOO, 0], ret = enum.next
+        assert_same FOO, ret[1]
+        assert_equal [:bar, BAR, 1], ret = enum.next
+        assert_same BAR, ret[1]
+        assert_raises StopIteration do
+          enum.next
+        end
+      end
+    end
+  end
+
+end