striuct 0.1.7 → 0.2.3

data/lib/striuct/conditions.rb

@@ -1,51 +1,54 @@
 class Striuct
 
-  # Useful Condition Patterns
+  # Condition Builders and Useful Conditions
+  #
+  # Any conditions need #pass?(arg, condition) method
+  # @author Kenichi Kamiya
+  # @example overview
+  #   class Person < Striuct
+  #     member :name, OR(String, Symbol, CAN(:to_str))
+  #     member :friends, GENERICS(AND(Person, NOT(->v{equal? v})))
   module Conditions
+    ANYTHING = Object.new.freeze
+    BOOLEAN = ->v{[true, false].any?{|bool|bool.equal? v}}
+  
     module_function
-
-    # @param [Object] condition
-    def conditionable?(condition)
-      case condition
-      when Proc, Method
-        condition.arity == 1
-      else
-        condition.respond_to? :===
-      end
+    
+    # The getter for a special condition.
+    # @return [ANYTHING] A condition always pass with any objects.
+    def ANYTHING?
+      ANYTHING
     end
 
-    # @param [Object] value
-    # @param [Proc, Method, #===] condition
-    # @param [self(class)] context
-    def pass?(value, condition, context)
-      if context && ! context.instance_of?(self)
-        raise ArgumentError,
-              "to change context is allowed in instance of #{self}"
-      end
+    alias_method :ANYTHING, :ANYTHING?  
+    alias_method :anything, :ANYTHING?
+    module_function :anything, :ANYTHING
 
-      case condition
-      when Proc
-        if context
-          context.instance_exec value, &condition
-        else
-          condition.call value
-        end
-      when Method
-        condition.call value
+    # true if object is sufficient for condition.
+    # @param [Object] object
+    def conditionable?(object)
+      case object
+      when ANYTHING
+        true
+      when Proc, Method
+        object.arity == 1
       else
-        condition === value
-      end ? true : false
+        object.respond_to? :===
+      end
     end
-
-    # @return [lambda] 
+    
+    # A condition builder.
+    # @return [lambda] A condition invert the original condition.
     def NOT(condition)
       unless conditionable? condition
         raise TypeError, 'wrong object for condition'
       end
       
-      ->v{! self.class.__send__(:pass?, v, condition, self)}
+      ->v{! pass?(v, condition)}
     end
 
+    # A innner method for some condition builders.
+    # For build conditions AND, NAND, OR, NOR, XOR, XNOR.
     # @return [lambda] 
     def _logical_operator(delegated, *conditions)
       unless conditions.all?{|c|conditionable? c}
@@ -54,37 +57,38 @@ class Striuct
       
       ->v{
         conditions.__send__(delegated) {|condition|
-          self.class.__send__(:pass?, v, condition, self)
+          pass? v, condition
         }
       }
     end
 
-    # @return [lambda] check "match all conditions"
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true if match all conditions
     def AND(cond1, cond2, *conds)
       _logical_operator :all?, cond1, cond2, *conds
     end
-    
-    alias_method :ALL, :AND
-    module_function :ALL
   
+    # A condition builder.
     # @return [lambda] 
     def NAND(cond1, cond2, *conds)
-      ! AND(cond1, cond2, *conds)
+      NOT AND(cond1, cond2, *conds)
     end
 
-    # @return [lambda] check "match any condition"
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true if match a any condition
     def OR(cond1, cond2, *conds)
       _logical_operator :any?, cond1, cond2, *conds
     end
 
-    alias_method :ANY, :OR
-    module_function :ANY
-
+    # A condition builder.
     # @return [lambda] 
     def NOR(cond1, cond2, *conds)
-      ! OR(cond1, cond2, *conds)
+      NOT OR(cond1, cond2, *conds)
     end
 
+    # A condition builder.
     # @return [lambda] 
     def XOR(cond1, cond2, *conds)
       _logical_operator :one?, cond1, cond2, *conds
@@ -93,30 +97,40 @@ class Striuct
     alias_method :ONE, :XOR
     module_function :ONE
 
+    # A condition builder.
     # @return [lambda] 
     def XNOR(cond1, cond2, *conds)
-      ! XOR(cond1, cond2, *conds)
+      NOT XOR(cond1, cond2, *conds)
     end
 
-    # @return [lambda] use #==
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true if a argment match under #== method
     def EQUAL(obj)
       ->v{obj == v}
     end
-    
-    # @return [lambda] use #equal?
+
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true if a argment match under #equal? method
     def SAME(obj)
       ->v{obj.equal? v}
     end
 
-    # @return [lambda] true when respond to all method names
-    def RESPONSIBLE(name1, *names)
-      names = [name1, *names]
-      unless names.all?{|s|[Symbol, String].any?{|klass|s.kind_of? klass}}
-        raise TypeError, 'only Symbol or String for name'
+    # A condition builder.
+    # @param [Symbol, String] messages
+    # @return [lambda]
+    #   this lambda return true if a argment respond to all messages
+    def RESPONSIBLE(message1, *messages)
+      messages = [message1, *messages]
+      unless messages.all?{|s|
+                [Symbol, String].any?{|klass|s.kind_of? klass}
+              }
+        raise TypeError, 'only Symbol or String for message'
       end
       
       ->v{
-        names.all?{|name|v.respond_to? name}
+        messages.all?{|message|v.respond_to? message}
       }
     end
 
@@ -124,8 +138,11 @@ class Striuct
     alias_method :RESPOND_TO, :RESPONSIBLE
     alias_method :responsible, :RESPONSIBLE
     module_function :CAN, :responsible, :RESPOND_TO
-    
-    # @return [lambda] true when faced no exceptions in checking all conditions
+
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true
+    #   if face no exception when a argment checking under all conditions 
     def NO_RAISES(condition1, *conditions)
       conditions = [condition1, *conditions]
       unless conditions.all?{|c|conditionable? c}
@@ -135,7 +152,7 @@ class Striuct
       ->v{
         conditions.all?{|condition|
           begin
-            self.class.__send__(:pass?, v, condition, self)
+            pass? v, condition
           rescue Exception
             false
           else
@@ -147,15 +164,18 @@ class Striuct
     
     alias_method :STILL, :NO_RAISES
     module_function :STILL
-    
-    # @return [lambda] true when catch the exception
+  
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true
+    #   if catch a kindly exception when a argment checking in a block parameter
     def CATCH(exception=Exception, &condition)
       raise ArgumentError unless conditionable? condition
       raise TypeError unless exception.ancestors.include? Exception
       
       ->v{
         begin
-          self.class.__send__(:pass?, v, condition, self)
+          pass? v, condition
         rescue exception
           true
         rescue Exception
@@ -169,7 +189,10 @@ class Striuct
     alias_method :RESCUE, :CATCH
     module_function :RESCUE
 
-    # @return [lambda] check "all included objects match any conditions"
+    # A condition builder.
+    # @return [lambda]
+    #   this lambda return true
+    #   if all included objects match all conditions
     def GENERICS(condition1, *conditions)
       conditions = [condition1, *conditions]
       unless conditions.all?{|c|conditionable? c}
@@ -177,9 +200,16 @@ class Striuct
       end
       
       ->list{
+        enum = (
+          (list.respond_to?(:each_value) && list.each_value) or
+          (list.respond_to?(:all?) && list) or
+          (list.respond_to?(:each) && list.each) or
+          return false
+        )
+      
         conditions.all?{|condition|
-          (list.respond_to?(:each_value) ? list.each_value : list.each).all?{|v|
-            self.class.__send__(:pass?, v, condition, self)
+          enum.all?{|v|
+            pass? v, condition
           }
         }
       }
@@ -187,8 +217,11 @@ class Striuct
     
     alias_method :generics, :GENERICS
     module_function :generics
-
+  
+    # A condition builder.
     # @return [lambda]
+    #   this lambda return true
+    #   if all lists including the object
     def MEMBER_OF(list1, *lists)
       lists = [list1, *lists]
       unless lists.all?{|l|l.respond_to? :all?}
@@ -202,24 +235,32 @@ class Striuct
     
     alias_method :member_of, :MEMBER_OF
     module_function :member_of
-    
-    BOOLEAN = OR(SAME(true), SAME(false))
 
+    # A getter for a useful condition.
     # @return [BOOLEAN] "true or false"
-    def boolean
+    def BOOLEAN?
       BOOLEAN
     end
 
-    alias_method :bool, :boolean
-    module_function :bool
+    alias_method :boolean, :BOOLEAN?
+    alias_method :bool, :BOOLEAN?
+    alias_method :BOOLEAN, :BOOLEAN?
+    alias_method :BOOL, :BOOLEAN?
+    alias_method :BOOL?, :BOOLEAN?
+    module_function :boolean, :bool, :BOOLEAN, :BOOL, :BOOL?
 
     STRINGABLE = OR(String, Symbol, CAN(:to_str), CAN(:to_sym))
 
+    # A getter for a useful condition.
     # @return [STRINGABLE] check "looks string family"
-    def stringable
+    def STRINGABLE?
       STRINGABLE
     end
     
+    alias_method :stringable, :STRINGABLE?
+    alias_method :STRINGABLE, :STRINGABLE?
+    module_function :stringable, :STRINGABLE
+    
     class << self
       private :_logical_operator
     end

data/lib/striuct/{subclassable → containable}/basic.rb

@@ -1,4 +1,4 @@
-class Striuct; module Subclassable
+class Striuct; module Containable
   # @group Basic
   
   def initialize(*values)
@@ -31,25 +31,25 @@ class Striuct; module Subclassable
   
   # @return [String]
   def inspect
-    "#<#{self.class} (StrictStruct)".tap do |s|
+    "#<#{self.class} (Striuct)".tap {|s|
       each_pair do |name, value|
         suffix = (has_default?(name) && default?(name)) ? '(default)' : nil
         s << " #{name}=#{value.inspect}#{suffix}"
       end
       
       s << ">"
-    end
+    }
   end
 
   # @return [String]
   def to_s
-    "#<struct #{self.class}".tap do |s|
+    "#<struct #{self.class}".tap {|s|
       each_pair do |name, value|
         s << " #{name}=#{value.inspect}"
       end
       
       s << '>'
-    end
+    }
   end
 
   # @param [Symbol, String, Fixnum] key
@@ -65,7 +65,7 @@ class Striuct; module Subclassable
     __subscript__(key){|name|true_name = name; __set__ name, value}
   rescue ConditionError
     $@ = [
-      "#{$@[-1].sub(/[^:]+\z/){''}}in `[#{key}(#{true_name})]=': #{$!.message}",
+      "#{$@[-1].sub(/[^:]+\z/){''}}in `[#{key.inspect}(#{true_name})]=': #{$!.message}",
       $@[-1]
     ]
 
@@ -107,9 +107,9 @@ class Striuct; module Subclassable
 
   # @param [Fixnum, Range] *keys
   # @return [Array]
-  def values_at(*keys)
+  def values_at(*_keys)
     [].tap {|r|
-      keys.each do |key|
+      _keys.each do |key|
         case key
         when Fixnum
           r << self[key]
@@ -132,4 +132,4 @@ class Striuct; module Subclassable
   end
 
   # @endgroup
-end; end
+end; end

data/lib/striuct/containable/classutil.rb

@@ -0,0 +1,22 @@
+class Striuct; module Containable
+
+
+# @author Kenichi Kamiya
+module ClassUtil
+
+  private
+  
+  def delegate_class_method(name)
+    define_method name do |*args, &block|
+      self.class.__send__ name, *args, &block
+    end
+  end
+  
+  def delegate_class_methods(name, *names)
+    [name, *names].each{|_name|delegate_class_method _name}
+  end
+
+end
+
+
+end; end

data/lib/striuct/{subclassable → containable}/eigen/basic.rb

@@ -1,4 +1,4 @@
-class Striuct; module Subclassable; module Eigen
+class Striuct; module Containable; module Eigen
   # @group Basic
 
   # @return [Array<Symbol>]
@@ -34,5 +34,13 @@ class Striuct; module Subclassable; module Eigen
     super
   end
 
+  def dup
+    r = super
+    @names, @flavors, @defaults, @aliases, @setter_validations, @getter_validations = 
+    *[@names, @flavors, @defaults, @aliases, @setter_validations, @getter_validations].map(&:dup)
+    @conditions, @inferences = @conditions.dup, @inferences.dup
+    r
+  end
+
   # @endgroup
 end; end; end

data/lib/striuct/{subclassable → containable}/eigen/constructor.rb

@@ -1,4 +1,4 @@
-class Striuct; module Subclassable; module Eigen
+class Striuct; module Containable; module Eigen
   # @group Constructor
   
   # @return [Subclass]

data/lib/striuct/{subclassable → containable}/eigen/handy.rb

@@ -1,13 +1,13 @@
-class Striuct; module Subclassable; module Eigen
+class Striuct; module Containable; module Eigen
   # @group Struct+ Handy
 
   # @yield [name] 
   # @yieldparam [Symbol] name - sequential under defined
   # @yieldreturn [self]
   # @return [Enumerator]
-  def each_name(&block)
+  def each_name
     return to_enum(__method__) unless block_given?
-    _names.each(&block)
+    _names.each{|name|yield name}
     self
   end
 
@@ -18,12 +18,26 @@ class Striuct; module Subclassable; module Eigen
   # @yieldparam [Integer] Index
   # @yieldreturn [self]
   # @return [Enumerator]
-  def each_index(&block)
+  def each_index
     return to_enum(__method__) unless block_given?
-    _names.each_index(&block)
+    _names.each_index{|index|yield index}
+    self
+  end
+
+  # @yield [name, index]
+  # @yieldparam [Symbol] name
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_name_with_index
+    return to_enum(__method__) unless block_given?
+    _names.each_with_index{|name, index|yield name, index}
     self
   end
   
+  alias_method :each_member_with_index, :each_name_with_index
+  alias_method :each_key_with_index, :each_name_with_index
+
   # @param [Symbol, String] name
   def original?(name)
     if member? name
@@ -87,6 +101,25 @@ class Striuct; module Subclassable; module Eigen
       raise "#{name} has no default value"
     end
   end
+  
+  # @return [Class]
+  def to_struct_class
+    raise 'No defined members' if names.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; end

data/lib/striuct/{subclassable → containable}/eigen/inner.rb

@@ -1,14 +1,6 @@
-class Striuct; module Subclassable; module Eigen
+class Striuct; module Containable; 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
@@ -31,6 +23,14 @@ class Striuct; module Subclassable; module Eigen
     @inferences.delete name
   end
   
+  def _mark_setter_validation(name)
+    @setter_validations[name] = true
+  end
+
+  def _mark_getter_validation(name)
+    @getter_validations[name] = true
+  end
+
   def _mark_inference(name)
     @inferences[name] = true
   end
@@ -39,8 +39,8 @@ class Striuct; module Subclassable; module Eigen
     @flavors[name] = flavor
   end
   
-  def _set_conditions(name, conditions)
-    @conditions[name] = conditions
+  def _set_condition(name, condition)
+    @conditions[name] = condition
   end
   
   def _set_default_value(name, value)
@@ -144,8 +144,8 @@ class Striuct; module Subclassable; module Eigen
     nil
   end
 
-  def __setter__!(name, *conditions, &flavor)
-    __set_conditions__! name, *conditions
+  def __setter__!(name, condition, &flavor)
+    __set_condition__! name, condition unless ANYTHING.equal? condition
     __set_flavor__! name, &flavor if block_given?
 
     define_method "#{name}=" do |value|
@@ -156,17 +156,11 @@ class Striuct; module Subclassable; module Eigen
 
   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
+  def __set_condition__!(name, condition)
+    if conditionable? condition
+      _set_condition name, condition
+    else
+      raise TypeError, 'wrong object for condition'
     end
  
     nil
@@ -192,19 +186,19 @@ class Striuct; module Subclassable; module Eigen
 
     raise ArgumentError unless conditionable? family
 
-    _set_conditions name, [family]
+    _set_condition name, family
     _remove_inference name
 
     nil
   end
   
-  def _conditions_for(name)
+  def _condition_for(name)
     @conditions[name]
   end
   
   # @param [Symbol, String] name
-  def conditions_for(name)
-    _conditions_for originalkey_for(keyable_for name)
+  def condition_for(name)
+    _condition_for originalkey_for(keyable_for name)
   end
   
   def _flavor_for(name)