striuct 0.0.11.1 → 0.1.7

data/lib/striuct/subclassable/eigen/inner.rb

@@ -0,0 +1,224 @@
+class Striuct; module Subclassable; module Eigen
+  # @group Use Only Inner
+
+  def dup
+    r = super
+    @names, @flavors, @defaults, @aliases = 
+    *[@names, @flavors, @defaults, @aliases].map(&:dup)
+    @conditions, @inferences = @conditions.dup, @inferences.dup
+    r
+  end
+
+  private
+
+  def _names
+    @names
+  end
+  
+  def _alias_member(aliased, original)
+    @aliases[aliased] = original
+  end
+  
+  def _original_for(aliased)
+    @aliases[aliased]
+  end
+
+  def _aliases_for(original)
+    @aliases.group_by{|aliased, org|org}[original]
+  end
+
+  def _remove_inference(name)
+    @inferences.delete name
+  end
+  
+  def _mark_inference(name)
+    @inferences[name] = true
+  end
+  
+  def _set_flavor(name, flavor)
+    @flavors[name] = flavor
+  end
+  
+  def _set_conditions(name, conditions)
+    @conditions[name] = conditions
+  end
+  
+  def _set_default_value(name, value)
+    @defaults[name] = value
+  end
+
+  # @param [Symbol, String, #to_sym, #to_str] name
+  def originalkey_for(name)
+    name = keyable_for name
+    
+    if _names.include? name
+      name
+    else
+      if original = _original_for(name)
+        original
+      else
+        raise NameError, "not defined member for #{name}"
+      end
+    end
+  end
+
+  # @param [Symbol, String, #to_sym, #to_str] name
+  # @return [Symbol] name(keyable)
+  def keyable_for(name)
+    return name if name.instance_of? Symbol
+
+    r = (
+      case name
+      when Symbol, String
+        name.to_sym
+      else
+        case
+        when name.respond_to?(:to_sym)
+          name.to_sym
+        when name.respond_to?(:to_str)
+          name.to_str.to_sym
+        else
+          raise TypeError
+        end
+      end
+    )
+
+    if r.instance_of? Symbol
+      r
+    else
+      raise 'must not happen'
+    end
+  end
+
+  # @param [Symbol] name
+  # @return [void]
+  # @yieldreturn [Boolean]
+  def _check_safety_naming(name)
+    estimation = _estimate_naming name
+    risk    = NAMING_RISKS[estimation]
+    plevels = PROTECT_LEVELS[@protect_level]
+    caution = "undesirable naming '#{name}', because #{estimation}"
+
+    r = (
+      case
+      when risk >= plevels[:error]
+        raise NameError, caution unless block_given?
+        false
+      when risk >= plevels[:warn]
+        warn caution unless block_given?
+        false
+      else
+        true
+      end
+    )
+
+    yield r if block_given?
+  end
+  
+  # @param [Symbol] name
+  # @return [Symbol]
+  def _estimate_naming(name)
+    if (instance_methods + private_instance_methods).include? name
+      return :conflict
+    end
+
+    return :no_ascii unless name.encoding.equal? Encoding::ASCII
+
+    case name
+    when /[\W]/, /\A[^a-zA-Z_]/, :''
+      :no_identifier
+    when /\Aeach/, /\A__[^_]*__\z/, /\A_[^_]*\z/, /[!?]\z/, /\Ato_/
+      :bad_manners
+    when /\A[a-zA-Z_]\w*\z/
+      :strict
+    else
+      raise 'must not happen'
+    end
+  end
+
+  def __getter__!(name) 
+    define_method name do
+      __get__ name
+    end
+    
+    nil
+  end
+
+  def __setter__!(name, *conditions, &flavor)
+    __set_conditions__! name, *conditions
+    __set_flavor__! name, &flavor if block_given?
+
+    define_method "#{name}=" do |value|
+        __set__ name, value
+    end
+ 
+    nil
+
+  end
+  
+  def __set_conditions__!(name, *conditions)
+    if conditions.reject!{|c|INFERENCE.equal? c}
+      _mark_inference name
+    end
+
+    unless conditions.empty?
+      if conditions.all?{|c|conditionable? c}
+        _set_conditions name, conditions
+      else
+        raise TypeError, 'wrong object for condition'
+      end
+    end
+ 
+    nil
+  end
+
+  def __set_flavor__!(name, &flavor)
+    if (arity = flavor.arity) == 1
+      _set_flavor name, flavor
+    else
+      raise ArgumentError, "wrong number of block argument #{arity} for 1"
+    end
+ 
+    nil
+  end
+
+  def __found_family__!(_caller, name, our)
+    family = our.class
+
+    raise 'must not happen' unless name.instance_of?(Symbol) and
+                                   inference?(name) and
+                                   member?(name) and
+                                   _caller.instance_of?(self)
+
+    raise ArgumentError unless conditionable? family
+
+    _set_conditions name, [family]
+    _remove_inference name
+
+    nil
+  end
+  
+  def _conditions_for(name)
+    @conditions[name]
+  end
+  
+  # @param [Symbol, String] name
+  def conditions_for(name)
+    _conditions_for originalkey_for(keyable_for name)
+  end
+  
+  def _flavor_for(name)
+    @flavors[name]
+  end
+
+  # @param [Symbol, String] name
+  def flavor_for(name)
+    _flavor_for originalkey_for(keyable_for name)
+  end
+  
+  def _default_for(name)
+    @defaults[name]
+  end
+
+  # @endgroup
+end; end; end

data/lib/striuct/subclassable/eigen/macro.rb

@@ -0,0 +1,108 @@
+class Striuct; module Subclassable; module Eigen
+  # @group Macro for Definition
+
+  private
+
+  # @macro [attach] protect_level
+  # @param [Symbol] level
+  # @return [nil]
+  # change protect level for risk of naming members
+  def protect_level(level)
+    raise NameError unless PROTECT_LEVELS.has_key? level
+    
+    @protect_level = level
+    nil
+  end
+
+  # @macro [attach] member
+  # @return [nil]
+  def define_member(name, *conditions, &flavor)
+    warn 'deprecated multiple conditions here, please use .#OR' if conditions.length >= 2
+    raise "already closed to add member in #{self}" if closed?
+    name = keyable_for name
+    raise ArgumentError, %Q!already exist name "#{name}"! if member? name
+    _check_safety_naming name
+
+    @names << name
+    __getter__! name
+    __setter__! name, *conditions, &flavor
+    nil
+  end
+
+  alias_method :def_member, :define_member
+  alias_method :member, :define_member
+
+  # @macro [attach] define_members
+  # @return [nil]
+  def define_members(*names)
+    raise "already closed to add members in #{self}" if closed?
+    unless names.length >= 1
+      raise ArgumentError, 'wrong number of arguments (0 for 1+)'
+    end
+    
+    names.each do |name|
+      define_member name
+    end
+
+    nil
+  end
+
+  alias_method :def_members, :define_members
+
+  # @param [Symbol, String] aliased
+  # @param [Symbol, String] original
+  # @return [nil]
+  def alias_member(aliased, original)
+    raise "already closed to add members in #{self}" if closed?
+    original = keyable_for original
+    aliased  = keyable_for aliased
+    raise NameError unless member? original
+    raise ArgumentError, %Q!already exist name "#{aliased}"! if member? aliased
+    _check_safety_naming aliased
+
+    alias_method aliased, original
+    alias_method "#{aliased}=", "#{original}="
+    _alias_member aliased, original
+
+    nil
+  end
+  
+  # @macro [attach] default
+  # @return [nil]
+  def set_default_value(name, value=nil, &block)
+    raise "already closed to modify member attributes in #{self}" if closed?
+    name = originalkey_for(keyable_for name)
+    raise "already settled default value for #{name}" if has_default? name
+
+    value = (
+      if block_given?
+        if value.nil?
+          if (arity = block.arity) == 2
+            SpecificContainer.new block
+          else
+            raise ArgumentError, "wrong number of block parameter #{arity} for 2"
+          end
+        else
+          raise ArgumentError, 'can not use value and block arguments'
+        end
+      else
+        value
+      end
+    )
+    
+    _set_default_value name, value
+    nil
+  end
+  
+  alias_method :default, :set_default_value
+  
+  # @return [self]
+  def fix_structural
+    [@names, @flavors, @defaults, @aliases].each(&:freeze)
+    self
+  end
+  
+  alias_method :close, :fix_structural
+  
+  # @endgroup
+end; end; end

data/lib/striuct/subclassable/eigen/safety.rb

@@ -0,0 +1,56 @@
+class Striuct; module Subclassable; module Eigen
+  # @group Struct+ Safety
+
+  # @return [INFERENCE] specific key of inference checker
+  def inference
+    INFERENCE
+  end
+  
+  # @param [Symbol, String] name
+  # inference checker is waiting yet
+  def inference?(name)
+    name = originalkey_for(keyable_for name)
+
+    @inferences.has_key? name
+  end
+
+  # @param [Symbol, String] name
+  def has_conditions?(name)
+    name = originalkey_for(keyable_for name)
+
+    @conditions.has_key?(name)
+  end
+  
+  alias_method :restrict?, :has_conditions?
+
+  # @param [Symbol, String] name
+  # @param [Object] value
+  # @param [Subclass] context - expect own instance
+  # value can set the member space
+  def sufficient?(name, value, context=nil)
+    name = originalkey_for(keyable_for name)
+
+    if restrict? name
+      conditions_for(name).any?{|c|pass? value, c, context}
+    else
+      true
+    end
+  end
+  
+  alias_method :accept?, :sufficient?
+  alias_method :valid?, :sufficient?
+  
+  # @param [Object] name
+  # accpeptable the name into own member, under protect level of runtime
+  def cname?(name)
+    _check_safety_naming(keyable_for name){|r|r}
+  rescue Exception
+    false
+  end
+  
+  def closed?
+    [@names, @flavors, @defaults, @aliases].any?(&:frozen?)
+  end
+
+  # @endgroup
+end; end; end

data/lib/striuct/subclassable/frame.rb

@@ -0,0 +1,33 @@
+require_relative 'classutil'
+require_relative 'eigen/frame'
+
+class Striuct
+
+  # @author Kenichi Kamiya
+  module Subclassable
+    extend ClassUtil
+    include Enumerable
+
+    SpecificContainer = Struct.new :value
+    
+    if respond_to? :private_constant
+      private_constant :SpecificContainer
+    end
+
+    class << self
+      private
+
+      def included(klass)
+        klass.extend Eigen
+      end
+    end
+  end
+
+end
+
+require_relative 'basic'
+require_relative 'safety'
+require_relative 'handy'
+require_relative 'hashlike'
+require_relative 'yaml'
+require_relative 'inner'

data/lib/striuct/subclassable/handy.rb

@@ -0,0 +1,57 @@
+class Striuct; module Subclassable  
+  # @group Struct + Handy
+  
+  # see self.class.*args
+  delegate_class_methods :has_default?, :default_for, :has_flavor?
+  
+  # @yield [index] 
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_index(&block)
+    return to_enum(__method__) unless block_given?
+    self.class.each_index(&block)
+    self
+  end
+
+  # @yield [value, index]
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_value_with_index(&block)
+    return to_enum(__method__) unless block_given?
+    each_value.with_index(&block)
+    self
+  end
+  
+  alias_method :each_with_index, :each_value_with_index
+  
+  # @param [Symbol, String] name
+  def assign?(name)
+    name = originalkey_for(keyable_for name)
+    
+    @db.has_key? name
+  end
+  
+  # @param [Symbol, String, Fixnum] key
+  def clear_at(key)
+    __subscript__(key){|name|__clear__ name}
+  end
+  
+  alias_method :unassign, :clear_at
+  alias_method :reset_at, :clear_at
+
+  # @param [Symbol, String] name
+  def default?(name)
+    name = originalkey_for(keyable_for name)
+
+    default_for(name) == self[name]
+  end
+
+  # all members aren't assigned
+  def empty?
+    each_name.none?{|name|assign? name}
+  end
+
+  # @endgroup
+end; end

data/lib/striuct/subclassable/hashlike.rb

@@ -0,0 +1,133 @@
+class Striuct; module Subclassable
+  # @group HashLike
+  
+  # @return [Hash]
+  def to_h(reject_no_assign=false)
+    return @db.dup if reject_no_assign
+
+    {}.tap {|h|
+      each_pair do |k, v|
+        h[k] = v
+      end
+    }
+  end
+
+  # @yield [name] 
+  # @yieldparam [Symbol] name - sequential under defined
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_name(&block)
+    return to_enum(__method__) unless block_given?
+    self.class.each_name(&block)
+    self
+  end
+
+  alias_method :each_member, :each_name
+  alias_method :each_key, :each_name
+
+  def has_value?(value)
+    @db.has_value? value
+  end
+
+  alias_method :value?, :has_value?
+
+  # @yield [name, value]
+  # keep truthy only (unassign falsy member)
+  # @see #each_pair
+  # @return [Enumerator]
+  # @yieldreturn [self]
+  # @yieldreturn [nil]
+  def select!
+    raise "can't modify frozen #{self.class}" if frozen?
+    return to_enum(__method__) unless block_given?
+
+    modified = false
+    each_pair do |name, value|
+      unless yield name, value
+        unassign name
+        modified = true
+      end
+    end
+    
+    modified ? self : nil
+  end
+
+  # @see #select!
+  # @yield [name, value]
+  # @return [Enumerator]
+  def keep_if(&block)
+    raise "can't modify frozen #{self.class}" if frozen?
+    return to_enum(__method__) unless block_given?
+    select!(&block)
+    self
+  end
+
+  # @see #select!
+  # keep falsy only (unassign truthy member)
+  # @yield [name, value]
+  # @return [Enumerator]
+  def reject!
+    raise "can't modify frozen #{self.class}" if frozen?
+    return to_enum(__method__) unless block_given?
+
+    modified = false
+    each_pair do |name, value|
+      if yield name, value
+        unassign name
+        modified = true
+      end
+    end
+    
+    modified ? self : nil
+  end
+
+  # @see #reject!
+  # @yield [name, value]
+  # @return [Enumerator]
+  def delete_if(&block)
+    raise "can't modify frozen #{self.class}" if frozen?
+    return to_enum(__method__) unless block_given?
+
+    reject!(&block)
+    self
+  end
+
+  # @param [Symbol, String] name
+  # @return [Array] [name, value]
+  def assoc(name)
+    name = originalkey_for(keyable_for name)
+
+    [name, self[name]]
+  end
+
+  # @return [Array] [name, value]
+  def rassoc(value)
+    each_pair.find{|pair|pair[1] == value}
+  end
+
+  # @see Hash#flatten
+  # @return [Array]
+  def flatten(level=1)
+    each_pair.to_a.flatten level
+  end
+
+  # @see #select!
+  # @yield [name, value]
+  # @return [Subclass]
+  def select(&block)
+    return to_enum(__method__) unless block_given?
+
+    dup.tap {|r|r.select!(&block)}
+  end
+
+  # @see #reject!
+  # @yield [name, value]
+  # @return [Subclass]
+  def reject(&block)
+    return to_enum(__method__) unless block_given?
+
+    dup.tap {|r|r.reject!(&block)}
+  end
+
+  # @endgroup
+end; end

data/lib/striuct/subclassable/inner.rb

@@ -0,0 +1,108 @@
+class Striuct; module Subclassable
+  private
+  
+  # @group Use Only Inner
+  
+  # see self.class.*args
+  delegate_class_methods(
+    :keyable_for, :flavor_for, :conditions_for, :originalkey_for
+  )
+  
+  def initialize_copy(original)
+    @db, @locks = @db.dup, {}
+  end
+
+  def __get__(name)
+    name = originalkey_for(keyable_for name)
+
+    @db[name]
+  end
+
+  def __set__(name, value)
+    raise "can't modify frozen #{self.class}" if frozen?
+    name = originalkey_for(keyable_for name)
+    raise "can't modify locked member #{name}" if lock? name
+
+    unless accept? name, value
+      raise ConditionError,
+            "#{value.inspect} is deficient for #{conditions_for(name).inspect}"
+    end
+          
+    if has_flavor? name
+      value = instance_exec value, &flavor_for(name)
+    end
+
+    if inference? name
+      self.class.__send__ :__found_family__!, self, name, value
+    end
+    
+    @db[name] = value
+  rescue ConditionError
+    unless /in \[\]=/ =~ caller[1].slice(/([^:]+)\z/)
+      $@.delete_if{|s|/#{Regexp.escape(File.dirname __FILE__)}/ =~ s}
+      $@.first.sub!(/([^:]+)\z/){"in `#{name}='"}
+      $@ << $@.last
+    end
+  
+    raise
+  end
+  
+  def __subscript__(key)
+    case key
+    when Symbol, String
+      name = keyable_for key
+      if member? name
+        yield originalkey_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)
+    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
+            value.value.call self, name
+          else
+            value
+          end
+        )
+      end
+    end
+  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