striuct 0.3.1 → 0.3.2

data/lib/striuct/classmethods/named.rb

@@ -0,0 +1,94 @@
+class Striuct; module ClassMethods
+
+  # @group Named
+
+  # @param [Symbol, String, #to_sym] name
+  # @return [Symbol]
+  def keyable_for(name)
+    name.to_sym
+  end
+
+  # @return [Array<Symbol>]
+  def autonyms
+    @autonyms.dup
+  end
+
+  alias_method :names, :autonyms
+  alias_method :members, :autonyms
+  alias_method :keys, :autonyms
+  
+  # @return [Array<Symbol>]
+  def all_members
+    @autonyms + @aliases.keys
+  end
+
+  def has_member?(name)
+    autonym_for name
+  rescue Exception
+    false
+  else
+    true
+  end
+  
+  alias_method :member?, :has_member?
+  alias_method :has_key?, :has_member?
+  alias_method :key?, :has_key?
+
+  # @param [Symbol, String, #to_sym, #to_str] name
+  # @return [Symbol]
+  def autonym_for(name)
+    name = keyable_for name
+    
+    if _autonyms.include? name
+      name
+    else
+      if autonym = _autonym_for(name)
+        autonym
+      else
+        raise NameError, "not defined member for #{name}"
+      end
+    end
+  end
+
+  # @param [Symbol, String] name
+  def autonym?(name)
+    name = keyable_for name
+    raise NameError unless member? name
+
+    @autonyms.include? name
+  end
+  
+  alias_method :original?, :autonym?
+  
+  # @param [Symbol, String] name
+  def aliased?(name)
+    name = keyable_for name
+    raise NameError unless member? name
+
+    @aliases.has_key? name
+  end
+  
+  # @param [Symbol, String] autonym
+  def has_aliases?(autonym)
+    raise NameError unless autonym? autonym
+
+    @aliases.has_value? autonym
+  end
+  
+  # @param [Symbol, String] autonym
+  # @return [Array<Symbol>]
+  def aliases_for(autonym)
+    autonym = keyable_for autonym
+    raise NameError unless has_aliases? autonym
+
+    _aliases_for autonym
+  end
+  
+  # @return [Hash] alias => autonym
+  def aliases
+    @aliases.dup
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/classmethods/object.rb

@@ -0,0 +1,24 @@
+class Striuct; module ClassMethods
+
+  # @group Basic Methods for Ruby's Object
+
+  # @return [self]
+  def freeze
+    __stores__.each(&:freeze)
+    super
+  end
+
+  # @return [Class]
+  def dup
+    r = super
+    @autonyms, @adjusters, @defaults, @aliases,
+    @setter_validations, @getter_validations = 
+    *[@autonyms, @adjusters, @defaults, @aliases,
+      @setter_validations, @getter_validations].map(&:dup)
+    @conditions, @inferences = @conditions.dup, @inferences.dup
+    r
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/classmethods/prevent_conflicts.rb

@@ -0,0 +1,89 @@
+class Striuct; module ClassMethods
+  
+  # @group Prevent Naming Conflicts
+
+  NAMING_RISKS = {
+    conflict:      10,
+    no_identifier:  9,
+    bad_manners:    5,
+    no_ascii:       3,
+    strict:         0 
+  }.freeze
+
+  PROTECT_LEVELS = {
+    struct:      {error: 99, warn: 99},
+    warning:     {error: 99, warn:  5},
+    error:       {error:  9, warn:  5},
+    prevent:     {error:  5, warn:  1},
+    nervous:     {error:  1, warn:  1}
+  }.each(&:freeze).freeze
+
+  # @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
+
+  private
+
+  # @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
+  
+  # @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
+  
+  # @endgroup
+
+end; end

data/lib/striuct/classmethods/requiremnets.rb

@@ -1,7 +1,12 @@
-require_relative 'constants'
 require_relative 'inner'
-require_relative 'basic'
+require_relative 'named'
+require_relative 'object'
+require_relative 'length'
+require_relative 'to_struct'
 require_relative 'constructor'
-require_relative 'handy'
+require_relative 'enum'
+require_relative 'default'
+require_relative 'adjustment'
 require_relative 'macro'
-require_relative 'safety'
+require_relative 'prevent_conflicts'
+require_relative 'validation'

data/lib/striuct/classmethods/to_struct.rb

@@ -0,0 +1,26 @@
+class Striuct; module ClassMethods
+
+  # @group To Ruby's Struct Class
+
+  # @return [Class]
+  def to_struct_class
+    raise 'No defined members' if autonyms.empty?
+
+    struct_klass = Struct.new(*names)
+  
+    if name
+      tail_name = name.slice(/[^:]+\z/)
+      if ::Striuct::Structs.const_defined?(tail_name) && 
+          ((already = ::Striuct::Structs.const_get(tail_name)).members == members)
+          already
+      else
+        ::Striuct::Structs.const_set tail_name, struct_klass
+      end
+    else
+      struct_klass
+    end
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/classmethods/validation.rb

@@ -0,0 +1,56 @@
+class Striuct; module ClassMethods
+
+  # @group Validation
+  
+  # @param [Symbol, String] name
+  # inference checker is waiting yet
+  def inference?(name)
+    autonym = autonym_for name
+
+    @inferences.has_key? autonym
+  end
+
+  # @param [Symbol, String] name
+  def has_validator?(name)
+    autonym = autonym_for name
+
+    @conditions.has_key? autonym
+  end
+  
+  alias_method :has_condition?, :has_validator?
+  alias_method :restrict?, :has_validator?
+  
+  # @param [Symbol, String] name
+  def validator_for(name)
+    _condition_for autonym_for(name)
+  end
+  
+  alias_method :condition_for, :validator_for
+
+  # @param [Symbol, String] name
+  def safety_getter?(name)
+    autonym = autonym_for name
+
+    @getter_validations.has_key? autonym
+  end
+  
+  alias_method :safety_reader?, :safety_getter?
+  
+  # @param [Symbol, String] name
+  def safety_setter?(name)
+    autonym = autonym_for name
+
+    @setter_validations.has_key? autonym
+  end
+
+  alias_method :safety_writer?, :safety_setter?
+
+  private
+  
+  def _condition_for(name)
+    @conditions[name]
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/assign.rb

@@ -0,0 +1,31 @@
+require_relative 'subscript'
+
+class Striuct; module InstanceMethods 
+
+  # @group Assign
+  
+  alias_method :assign, :[]=
+  
+  # @param [Symbol, String] name
+  def assign?(name)
+    autonym = autonym_for name
+    
+    @db.has_key? autonym
+  end
+  
+  # @param [Symbol, String, Fixnum] key
+  def clear_at(key)
+    __subscript__(key){|autonym|__clear__ autonym}
+  end
+  
+  alias_method :unassign, :clear_at
+  alias_method :reset_at, :clear_at
+
+  # all members aren't assigned
+  def empty?
+    autonyms.none?{|autonym|assign? autonym}
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/compare.rb

@@ -0,0 +1,31 @@
+class Striuct; module InstanceMethods
+
+  # @group Compare with other
+  
+  # @return [Boolean]
+  def ==(other)
+    __compare_all__ other, :==
+  end
+
+  alias_method :===, :==
+  
+  def eql?(other)
+    __compare_all__ other, :eql?
+  end
+
+  # @return [Integer]
+  def hash
+    @db.hash
+  end
+
+  private  
+
+  # @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/default.rb

@@ -0,0 +1,14 @@
+class Striuct; module InstanceMethods 
+
+  # @group Default Value
+  
+  # @param [Symbol, String] name
+  def default?(name)
+    autonym = autonym_for name
+
+    default_for(autonym) == self[autonym]
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/delegate_class_methods.rb

@@ -0,0 +1,20 @@
+class Striuct; module InstanceMethods
+
+  # @group Delegate Class Methods
+  
+  # @see self.class.*args
+  delegate_class_methods(
+    :keyable_for, :autonym_for, :aliases_for,
+    :validator_for, :condition_for,
+    :adjuster_for, :flavor_for,
+    :members, :keys, :names, :autonyms, :all_members, :aliases,
+    :has_member?, :member?, :has_key?, :key?,
+    :length, :size,
+    :restrict?, :has_validator?, :has_condition?,
+    :safety_getter?, :safety_reader?, :safety_setter?, :safty_writer?, :inference?,
+    :has_default?, :default_for, :has_adjuster?, :has_flavor?
+  )
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/enum.rb

@@ -0,0 +1,104 @@
+class Striuct; module InstanceMethods 
+
+  # @group Enumerative
+
+  # @yield [autonym] 
+  # @yieldparam [Symbol] autonym - sequential under defined
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_autonym(&block)
+    return to_enum(__callee__) unless block_given?
+
+    self.class.each_autonym(&block)
+    self
+  end
+
+  alias_method :each_name, :each_autonym
+  alias_method :each_member, :each_autonym
+  alias_method :each_key, :each_autonym
+
+  # @yield [value]
+  # @yieldparam [Object] value - sequential under defined
+  # @see #each_autonym
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_value
+    return to_enum(__callee__) unless block_given?
+  
+    each_autonym{|autonym|yield self[autonym]}
+  end
+  
+  alias_method :each, :each_value
+
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
+  # @yieldparam [Object] value
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  # @see #each_autonym
+  # @see #each_value 
+  def each_pair
+    return to_enum(__callee__) unless block_given?
+
+    each_autonym{|autonym|yield autonym, self[autonym]}
+  end
+
+  # @yield [index] 
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_index
+    return to_enum(__callee__) unless block_given?
+
+    self.class.each_index{|index|yield index}
+    self
+  end
+
+  # @yield [autonym, index]
+  # @yieldparam [Symbol] autonym
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_autonym_with_index
+    return to_enum(__callee__) unless block_given?
+
+    self.class.each_autonym_with_index{|autonym, index|yield autonym, index}
+    self
+  end
+
+  alias_method :each_name_with_index, :each_autonym_with_index
+  alias_method :each_member_with_index, :each_autonym_with_index
+  alias_method :each_key_with_index, :each_autonym_with_index
+
+  # @yield [value, index]
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_value_with_index
+    return to_enum(__callee__) unless block_given?
+
+    each_value.with_index{|value, index|yield value, index}
+    self
+  end
+  
+  alias_method :each_with_index, :each_value_with_index
+  
+  # @yield [autonym, value, index]
+  # @yieldparam [Symbol] autonym
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_pair_with_index
+    return to_enum(__callee__) unless block_given?
+
+    index = 0
+    each_pair do |autonym, value|
+      yield autonym, value, index
+      index += 1
+    end
+    self
+  end
+
+  # @endgroup
+
+end; end

data/lib/striuct/instancemethods/{hashlike.rb → hashy.rb}

@@ -1,30 +1,22 @@
+require_relative 'subscript'
+
 class Striuct; module InstanceMethods
-  # @group HashLike
+
+  # @group Like Ruby's Hash
+  
+  alias_method :fetch, :[]
   
   # @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
+      each_pair do |autonym, val|
+        h[autonym] = val
       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
@@ -32,20 +24,20 @@ class Striuct; module InstanceMethods
   alias_method :value?, :has_value?
 
   # keep truthy only (unassign falsy member)
-  # @yield [name, value]
-  # @yieldparam [Symbol] name
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
   # @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?
+    return to_enum(__callee__) unless block_given?
 
     modified = false
-    each_pair do |name, value|
-      unless yield name, value
-        unassign name
+    each_pair do |autonym, value|
+      unless yield autonym, value
+        unassign autonym
         modified = true
       end
     end
@@ -54,29 +46,30 @@ class Striuct; module InstanceMethods
   end
 
   # @see #select!
-  # @yield [name, value]
-  # @yieldparam [Symbol] name
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
   # @return [Enumerator]
   def keep_if(&block)
     raise "can't modify frozen #{self.class}" if frozen?
-    return to_enum(__method__) unless block_given?
+    return to_enum(__callee__) unless block_given?
+
     select!(&block)
     self
   end
 
   # @see #select!
   # keep falsy only (unassign truthy member)
-  # @yield [name, value]
-  # @yieldparam [Symbol] name
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
   # @return [Enumerator]
   def reject!
     raise "can't modify frozen #{self.class}" if frozen?
-    return to_enum(__method__) unless block_given?
+    return to_enum(__callee__) unless block_given?
 
     modified = false
-    each_pair do |name, value|
-      if yield name, value
-        unassign name
+    each_pair do |autonym, value|
+      if yield autonym, value
+        unassign autonym
         modified = true
       end
     end
@@ -85,28 +78,28 @@ class Striuct; module InstanceMethods
   end
 
   # @see #reject!
-  # @yield [name, value]
-  # @yieldparam [Symbol] name
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
   # @return [Enumerator]
   def delete_if(&block)
     raise "can't modify frozen #{self.class}" if frozen?
-    return to_enum(__method__) unless block_given?
+    return to_enum(__callee__) unless block_given?
 
     reject!(&block)
     self
   end
 
   # @param [Symbol, String] name
-  # @return [Array] e.g [name, value]
+  # @return [Array] e.g [autonym, value]
   def assoc(name)
-    name = autonym_for name
+    autonym = autonym_for name
 
-    [name, self[name]]
+    [autonym, self[name]]
   end
 
-  # @return [Array] [name, value]
+  # @return [Array] [autonym, value]
   def rassoc(value)
-    each_pair.find{|pair|pair[1] == value}
+    each_pair.find{|_, val|val == value}
   end
 
   # @see Hash#flatten
@@ -116,24 +109,25 @@ class Striuct; module InstanceMethods
   end
 
   # @see #select!
-  # @yield [name, value]
-  # @yieldparam [Symbol] name
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
   # @return [Striuct]
   def select(&block)
-    return to_enum(__method__) unless block_given?
+    return to_enum(__callee__) unless block_given?
 
     dup.tap {|r|r.select!(&block)}
   end
 
   # @see #reject!
-  # @yield [name, value]
-  # @yieldparam [Symbol] name
+  # @yield [autonym, value]
+  # @yieldparam [Symbol] autonym
   # @return [Striuct]
   def reject(&block)
-    return to_enum(__method__) unless block_given?
+    return to_enum(__callee__) unless block_given?
 
     dup.tap {|r|r.reject!(&block)}
   end
 
   # @endgroup
+
 end; end