striuct 0.3.1 → 0.3.2

data/lib/striuct/instancemethods/inner.rb

@@ -1,23 +1,14 @@
 class Striuct; module InstanceMethods
 
-  private
-  
   # @group Use Only Inner
-  
-  # see self.class.*args
-  delegate_class_methods(
-    :keyable_for, :flavor_for, :condition_for, :autonym_for
-  )
-  
-  def initialize_copy(original)
-    @db, @locks = @db.dup, {}
-  end
+
+  private
 
   def __get__(name)
-    name = autonym_for name
-    value = @db[name]
+    autonym = autonym_for name
+    value = @db[autonym]
   
-    if safety_getter?(name) and !accept?(name, value)
+    if safety_getter?(autonym) and !accept?(autonym, value)
       raise ::Validation::InvalidReadingError,
             "#{value.inspect} is deficient for #{name} in #{self.class}"
     end
@@ -27,27 +18,27 @@ class Striuct; module InstanceMethods
 
   def __set__(name, value)
     raise "can't modify frozen #{self.class}" if frozen?
-    name = autonym_for name
-    raise "can't modify locked member #{name}" if lock? name
+    autonym = autonym_for name
+    raise "can't modify locked member #{name}" if lock? autonym
 
-    if has_flavor? name
+    if has_adjuster? autonym
       begin
-        value = instance_exec value, &flavor_for(name)
+        value = instance_exec value, &adjuster_for(autonym)
       rescue Exception
         raise ::Validation::UnmanagebleError
       end
     end
 
-    if safety_setter?(name) and !accept?(name, value)
+    if safety_setter?(autonym) and !accept?(autonym, value)
       raise ::Validation::InvalidWritingError,
             "#{value.inspect} is deficient for #{name} in #{self.class}"
     end
 
-    if inference? name
-      self.class.__send__ :__found_family__!, self, name, value
+    if inference? autonym
+      self.class.__send__ :__found_family__!, self, autonym, value
     end
     
-    @db[name] = value
+    @db[autonym] = value
   rescue ::Validation::InvalidError
     unless /in \[\]=/ =~ caller[1].slice(/([^:]+)\z/)
       $!.backtrace.delete_if{|s|/#{Regexp.escape(File.dirname __FILE__)}/ =~ s}
@@ -57,65 +48,13 @@ class Striuct; module InstanceMethods
     raise
   end
   
-  def __subscript__(key)
-    case key
-    when Symbol, String
-      name = keyable_for key
-      if member? name
-        yield autonym_for(name)
-      else
-        raise NameError
-      end
-    when Fixnum
-      if name = members[key]
-        yield name
-      else
-        raise IndexError
-      end
-    else
-      raise ArgumentError
-    end
-  end
-  
-  # @param [Symbol] name
-  def __clear__(name)
+  # @param [Symbol] autonym
+  def __clear__(autonym)
     raise "can't modify frozen #{self.class}" if frozen?
     
-    @db.delete name
-  end
-
-  def replace_values(*values)
-    unless values.size <= size
-      raise ArgumentError, "struct size differs (max: #{size})"
-    end
-
-    values.each_with_index do |value, index|
-      self[index] = value
-    end
-      
-    excess = members.last(size - values.size)
-      
-    excess.each do |name|
-      if has_default? name
-        self[name] = (
-          if (value = default_for name).kind_of? SpecificContainer
-            block = value.value
-            args = [self, name][0, block.arity]
-            block.call(*args)
-          else
-            value
-          end
-        )
-      end
-    end
+    @db.delete autonym
   end
 
-  # @param [Symbol] method
-  def __compare_all__(other, method)
-    instance_of?(other.class) && \
-    each_pair.all?{|k, v|v.__send__ method, other[k]}
-  end
-  
   # @endgroup
 
 end; end

data/lib/striuct/instancemethods/lock.rb

@@ -0,0 +1,51 @@
+class Striuct; module InstanceMethods
+
+  # @group Lock
+  
+  # @overload lock(key)
+  #   lock a setter for key 
+  #   @param [Symbol, String, Fixnum] key
+  # @overload lock(true)
+  #   lock setters for all members
+  #   @param [true] true
+  # @return [self]
+  def lock(key=true)
+    raise "can't modify frozen #{self.class}" if frozen?
+    
+    if key.equal? true
+      autonyms.each do |autonym|
+        @locks[autonym] = true
+      end
+    else
+      __subscript__(key){|autonym|@locks[autonym] = true}
+    end
+
+    self
+  end
+  
+  # @see #lock
+  def lock?(key=true)
+    if key.equal? true
+      autonyms.all?{|autonym|@locks[autonym]}
+    else
+      __subscript__(key){|autonym|@locks[autonym]} || false
+    end
+  end
+  
+  private
+  
+  def unlock(key=true)
+    raise "can't modify frozen #{self.class}" if frozen?
+    
+    if key.equal? true
+      @locks.clear
+    else
+      __subscript__(key){|autonym|@locks.delete autonym}
+    end
+
+    self
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/object.rb

@@ -0,0 +1,47 @@
+class Striuct; module InstanceMethods
+
+  # @group Basic Methods for Ruby's Object
+  
+  def initialize(*values)
+    @db, @locks = {}, {}
+    replace_values(*values)
+  end
+  
+  # @return [String]
+  def inspect
+    "#<#{self.class} (Striuct)".tap {|s|
+      each_pair do |autonym, value|
+        suffix = (has_default?(autonym) && default?(autonym)) ? '(default)' : nil
+        s << " #{autonym}=#{value.inspect}#{suffix}"
+      end
+      
+      s << ">"
+    }
+  end
+
+  # @return [String]
+  def to_s
+    "#<struct #{self.class}".tap {|s|
+      each_pair do |autonym, value|
+        s << " #{autonym}=#{value.inspect}"
+      end
+      
+      s << '>'
+    }
+  end
+
+  # @return [self]
+  def freeze
+    [@db, @locks].each(&:freeze)
+    super
+  end
+  
+  private
+  
+  def initialize_copy(original)
+    @db, @locks = @db.dup, {}
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/requirements.rb

@@ -1,6 +1,15 @@
 require_relative 'singleton_class'
+require_relative 'delegate_class_methods'
 require_relative 'inner'
-require_relative 'basic'
-require_relative 'handy'
-require_relative 'hashlike'
+require_relative 'object'
+require_relative 'compare'
+require_relative 'values'
+require_relative 'to_struct'
+require_relative 'default'
+require_relative 'enum'
+require_relative 'hashy'
+require_relative 'subscript'
+require_relative 'assign'
+require_relative 'lock'
+require_relative 'validation'
 require_relative 'safety'

data/lib/striuct/instancemethods/safety.rb

@@ -1,76 +1,12 @@
 class Striuct; module InstanceMethods
-  # @group Struct+ Safety
-  
-  # see self.class.*args
-  delegate_class_methods :restrict?, :has_condition?,
-    :safety_getter?, :safety_reader?, :safety_setter?, :safty_writer?, :inference?
-
-  # @param [Symbol, String] name
-  # @param [Object] value - no argument and use own
-  # passed under any condition
-  def sufficient?(name, value=self[name])
-    name = autonym_for name
-    return true unless restrict? name
-    
-    _valid? condition_for(name), value
-  end
-  
-  alias_method :accept?, :sufficient?
-  alias_method :valid?, :sufficient?
 
-  # all members passed under any condition
-  def strict?
-    each_pair.all?{|name, value|sufficient? name, value}
-  end
+  # @group Safety
   
   # freezed, fixed familar members, all members passed any condition
   def secure?
     (frozen? || lock?) && self.class.closed? && strict?
   end
 
-  # @overload lock(key)
-  #   lock a setter for key 
-  #   @param [Symbol, String, Fixnum] key
-  # @overload lock(true)
-  #   lock setters for all members
-  #   @param [true] true
-  # @return [self]
-  def lock(key=true)
-    raise "can't modify frozen #{self.class}" if frozen?
-    
-    if key.equal? true
-      names.each do |name|
-        @locks[name] = true
-      end
-    else
-      __subscript__(key){|name|@locks[name] = true}
-    end
-
-    self
-  end
-
-  # @see #lock
-  def lock?(key=true)
-    if key.equal? true
-      names.all?{|name|@locks[name]}
-    else
-      __subscript__(key){|name|@locks[name]} || false
-    end
-  end
-  
-  private
-  
-  def unlock(key=true)
-    raise "can't modify frozen #{self.class}" if frozen?
-    
-    if key.equal? true
-      @locks.clear
-    else
-      __subscript__(key){|name|@locks.delete name}
-    end
-
-    self
-  end
-
   # @endgroup
+
 end; end

data/lib/striuct/instancemethods/singleton_class.rb

@@ -4,12 +4,15 @@ class Striuct; module InstanceMethods
     
     private
     
+    # @param [Symbol, String] name
     def delegate_class_method(name)
       define_method name do |*args, &block|
         self.class.__send__ name, *args, &block
       end
     end
-    
+
+    # @param [Symbol, String] name
+    # @param [Symbol, String] names
     def delegate_class_methods(name, *names)
       [name, *names].each{|_name|delegate_class_method _name}
     end

data/lib/striuct/instancemethods/subscript.rb

@@ -0,0 +1,55 @@
+class Striuct; module InstanceMethods
+
+  # @group Subscript
+
+  # @param [Symbol, String, Fixnum] key
+  def [](key)
+    __subscript__(key){|autonym|__get__ autonym}
+  end
+  
+  # @param [Symbol, String, Fixnum] key
+  # @param [Object] value
+  # @return [value]
+  def []=(key, value)
+    true_name = nil
+    __subscript__(key){|autonym|
+      true_name = autonym
+      __set__ autonym, value
+    }
+  rescue Validation::InvalidWritingError
+    $!.set_backtrace([
+      "#{$!.backtrace[-1].sub(/[^:]+\z/){''}}in `[#{key.inspect}(#{true_name})]=': #{$!.message}",
+      $!.backtrace[-1]
+    ])
+
+    raise
+  end
+
+  private
+
+  # @param [Symbol, String, Fixnum] key
+  # @yield [autonym]
+  # @yieldparam [Symbol] autonym
+  def __subscript__(key)
+    case key
+    when Symbol, String
+      name = keyable_for key
+      if member? name
+        yield autonym_for(name)
+      else
+        raise NameError
+      end
+    when Fixnum
+      if autonym = autonyms[key]
+        yield autonym
+      else
+        raise IndexError
+      end
+    else
+      raise ArgumentError
+    end
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/to_struct.rb

@@ -0,0 +1,12 @@
+class Striuct; module InstanceMethods 
+
+  # @group To Ruby's Struct
+  
+  # @return [Struct]
+  def to_struct
+    self.class.to_struct_class.new(*values)
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/validation.rb

@@ -0,0 +1,25 @@
+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
+    return true unless restrict? autonym
+    
+    _valid? condition_for(autonym), value
+  end
+  
+  alias_method :accept?, :sufficient?
+  alias_method :valid?, :sufficient?
+
+  # all members passed under any condition
+  def strict?
+    each_pair.all?{|autonym, value|sufficient? autonym, value}
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/values.rb

@@ -0,0 +1,64 @@
+class Striuct; module InstanceMethods
+
+  # @group Behavior under Values
+
+  # @return [Array]
+  def values
+    each_value.to_a
+  end
+  
+  alias_method :to_a, :values
+
+  # @param [Fixnum, Range] _keys
+  # @return [Array]
+  def values_at(*_keys)
+    [].tap {|r|
+      _keys.each do |key|
+        case key
+        when Fixnum
+          r << self[key]
+        when Range
+          key.each do |n|
+            raise TypeError unless n.instance_of? Fixnum
+            r << self[n]
+          end
+        else
+          raise TypeError
+        end
+      end
+    }
+  end
+
+  # @return [self]
+  def replace_values(*values)
+    unless values.size <= size
+      raise ArgumentError, "struct size differs (max: #{size})"
+    end
+
+    values.each_with_index do |value, index|
+      self[index] = value
+    end
+      
+    excess = autonyms.last(size - values.size)
+      
+    excess.each do |autonym|
+      if has_default? autonym
+        self[autonym] = (
+          value = default_for autonym
+          if value.kind_of? DefaultProcHolder
+            block = value.value
+            args = [self, autonym][0, block.arity]
+            block.call(*args)
+          else
+            value
+          end
+        )
+      end
+    end
+    
+    self
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/singleton_class.rb

@@ -9,18 +9,18 @@ class Striuct
     alias_method :new_instance, :new
     private :new_instance
     
-    # @param [Symbol, String] *names
+    # @param [Symbol, String] autonyms
     # @return [Class]
-    def new(*names, &block)
+    def new(*autonyms, &block)
       # warning for Ruby's Struct.new user
-      first = names.first
+      first = autonyms.first
       if first.instance_of?(String) and /\A[A-Z]/ =~ first
         warn "no define constant #{first}"
       end
 
       Class.new self do
-        names.each do |name|
-          member name
+        autonyms.each do |autonym|
+          add_member autonym
         end
 
         class_eval(&block) if block_given?
@@ -34,7 +34,7 @@ class Striuct
 
       new(&block).tap do |subclass|
         subclass.instance_eval do
-          raise 'not yet finished' if members.empty?
+          raise 'not yet finished' if autonyms.empty?
           close
         end
       end
@@ -53,7 +53,7 @@ class Striuct
         else
           [
            *[
-             @names, @conditions, @flavors, @defaults,
+             @autonyms, @conditions, @adjusters, @defaults,
              @inferences, @aliases, @setter_validations,
              @getter_validations
             ].map(&:dup), @protect_level
@@ -72,15 +72,15 @@ class Striuct
           include InstanceMethods
         end
         
-        @names, @conditions, @flavors, @defaults,
+        @autonyms, @conditions, @adjusters, @defaults,
         @inferences, @aliases, @setter_validations,
         @getter_validations, @protect_level = *attributes
         
         singleton_class.instance_eval do
           define_method :initialize_copy do |original|
-            @names, @flavors, @defaults, @aliases,
+            @autonyms, @adjusters, @defaults, @aliases,
             @setter_validations, @getter_validations = 
-            *[@names, @flavors, @defaults, @aliases,
+            *[@autonyms, @adjusters, @defaults, @aliases,
               @setter_validations, @getter_validations].map(&:dup)
             @conditions, @inferences = @conditions.dup, @inferences.dup
           end

data/lib/striuct/specificcontainer.rb

@@ -10,8 +10,10 @@ class Striuct
 
   end
   
+  class DefaultProcHolder < SpecificContainer; end
+
   if respond_to? :private_constant
-    private_constant :SpecificContainer
+    private_constant :SpecificContainer, :DefaultProcHolder
   end
 
 end

data/lib/striuct/version.rb

@@ -1,5 +1,5 @@
 class Striuct
 
-  VERSION = '0.3.1'.freeze
+  VERSION = '0.3.2'.freeze
 
 end

data/striuct.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = '>=1.9.2'
   gem.add_runtime_dependency 'validation', '~>0.0.3.1'
-  gem.add_runtime_dependency 'keyvalidatable', '~>0.0.2'
+  gem.add_runtime_dependency 'keyvalidatable', '~>0.0.3'
   gem.add_development_dependency 'yard', '>=0.8.2.1'
 end
 

data/test/test_striuct_subclass_alias_member.rb

@@ -23,9 +23,9 @@ class TestStriuctAliasMember < Test::Unit::TestCase
     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)
+    adjuster = Sth.__send__(:adjuster_for, :abc)
+    assert_kind_of Proc, adjuster
+    assert_same adjuster, Sth.__send__(:adjuster_for, :bar)
     assert_equal 8, sth.abc
     sth.abc = 5
     assert_equal 5, sth.bar

data/test/test_striuct_subclass_for_pairs.rb

@@ -3,11 +3,18 @@ require_relative 'helper'
 class TestStriuctForPairs < Test::Unit::TestCase
 
   Sth = Striuct.new :foo, :bar, :hoge
+  SampleStruct = Struct.new :foo, :bar, :hoge
   
-  def test_for_pairs
+  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