striuct 0.1.7 → 0.2.3

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

@@ -1,9 +1,8 @@
-class Striuct; module Subclassable; module Eigen
+class Striuct; module Containable; module Eigen
   # @group Macro for Definition
 
   private
 
-  # @macro [attach] protect_level
   # @param [Symbol] level
   # @return [nil]
   # change protect level for risk of naming members
@@ -14,41 +13,51 @@ class Striuct; module Subclassable; module Eigen
     nil
   end
 
-  # @macro [attach] member
+  VALID_MEMBER_OPTIONS = [
+    :inference,
+    :reader_validation,
+    :getter_validation,
+    :writer_validation,
+    :setter_validation
+  ].freeze
+  
+  DEFAULT_MEMBER_OPTIONS = {
+    setter_validation: true
+  }.freeze
+
+  # @param [Symbol, String] name
+  # @param [#===, Proc, Method, ANYTHING] condition
+  # @param [Hash] options
   # @return [nil]
-  def define_member(name, *conditions, &flavor)
-    warn 'deprecated multiple conditions here, please use .#OR' if conditions.length >= 2
+  def add_member(name, condition=ANYTHING, options=DEFAULT_MEMBER_OPTIONS, &flavor)
     raise "already closed to add member in #{self}" if closed?
+    options = DEFAULT_MEMBER_OPTIONS.merge options
+    raise ArgumentError, 'invalid option parameter is' unless (options.keys - VALID_MEMBER_OPTIONS).empty?
     name = keyable_for name
     raise ArgumentError, %Q!already exist name "#{name}"! if member? name
     _check_safety_naming name
+    _mark_setter_validation name if options[:setter_validation] or options[:writer_validation]
+    _mark_getter_validation name if options[:getter_validation] or options[:reader_validation]
+    _mark_inference name if options[:inference]
 
     @names << name
     __getter__! name
-    __setter__! name, *conditions, &flavor
+    __setter__! name, condition, &flavor
     nil
   end
 
-  alias_method :def_member, :define_member
-  alias_method :member, :define_member
+  alias_method :member, :add_member
 
-  # @macro [attach] define_members
+  # @param [Symbol, String] name
+  # @param [Symbol, String] *names
   # @return [nil]
-  def define_members(*names)
+  def add_members(name, *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
-
+    [name, *names].each {|_name|add_member _name}
     nil
   end
 
-  alias_method :def_members, :define_members
-
   # @param [Symbol, String] aliased
   # @param [Symbol, String] original
   # @return [nil]
@@ -63,11 +72,10 @@ class Striuct; module Subclassable; module Eigen
     alias_method aliased, original
     alias_method "#{aliased}=", "#{original}="
     _alias_member aliased, original
-
     nil
   end
   
-  # @macro [attach] default
+  # @param [Symbol, String] name
   # @return [nil]
   def set_default_value(name, value=nil, &block)
     raise "already closed to modify member attributes in #{self}" if closed?
@@ -77,7 +85,7 @@ class Striuct; module Subclassable; module Eigen
     value = (
       if block_given?
         if value.nil?
-          if (arity = block.arity) == 2
+          if (arity = block.arity) <= 2
             SpecificContainer.new block
           else
             raise ArgumentError, "wrong number of block parameter #{arity} for 2"
@@ -97,12 +105,13 @@ class Striuct; module Subclassable; module Eigen
   alias_method :default, :set_default_value
   
   # @return [self]
-  def fix_structural
+  def close_member
     [@names, @flavors, @defaults, @aliases].each(&:freeze)
     self
   end
   
-  alias_method :close, :fix_structural
+  alias_method :fix_structural, :close_member
+  alias_method :close, :close_member
   
   # @endgroup
-end; end; end
+end; end; end

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

@@ -1,10 +1,5 @@
-class Striuct; module Subclassable; module Eigen
+class Striuct; module Containable; 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
@@ -15,31 +10,32 @@ class Striuct; module Subclassable; module Eigen
   end
 
   # @param [Symbol, String] name
-  def has_conditions?(name)
+  def has_condition?(name)
     name = originalkey_for(keyable_for name)
 
     @conditions.has_key?(name)
   end
   
-  alias_method :restrict?, :has_conditions?
+  alias_method :restrict?, :has_condition?
 
   # @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)
+  def safety_getter?(name)
     name = originalkey_for(keyable_for name)
 
-    if restrict? name
-      conditions_for(name).any?{|c|pass? value, c, context}
-    else
-      true
-    end
+    @getter_validations.has_key?(name)
   end
   
-  alias_method :accept?, :sufficient?
-  alias_method :valid?, :sufficient?
+  alias_method :safety_reader?, :safety_getter?
   
+  # @param [Symbol, String] name
+  def safety_setter?(name)
+    name = originalkey_for(keyable_for name)
+
+    @setter_validations.has_key?(name)
+  end
+
+  alias_method :safety_writer?, :safety_setter?
+
   # @param [Object] name
   # accpeptable the name into own member, under protect level of runtime
   def cname?(name)

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

@@ -1,10 +1,12 @@
-require_relative '../../conditions'
+require_relative '../conditions'
+require_relative '../flavors'
 
-class Striuct; module Subclassable
+class Striuct; module Containable
 
 # @author Kenichi Kamiya
 module Eigen  
   include Conditions
+  include Flavors
   
   NAMING_RISKS = {
     conflict:      10,
@@ -21,19 +23,13 @@ module Eigen
     prevent:     {error:  5, warn:  1},
     nervous:     {error:  1, warn:  1}
   }.each(&:freeze).freeze
-  
-  INFERENCE = Object.new.freeze
-
-  if respond_to? :private_constant
-    private_constant :INFERENCE
-  end
 end
 
 end; end
 
-require_relative 'basic'
-require_relative 'constructor'
-require_relative 'safety'
-require_relative 'handy'
-require_relative 'macro'
-require_relative 'inner'
+require_relative 'eigen/basic'
+require_relative 'eigen/constructor'
+require_relative 'eigen/safety'
+require_relative 'eigen/handy'
+require_relative 'eigen/macro'
+require_relative 'eigen/inner'

data/lib/striuct/containable/handy.rb

@@ -0,0 +1,91 @@
+class Striuct; module Containable 
+  # @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
+    return to_enum(__method__) unless block_given?
+    self.class.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?
+    self.class.each_name_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
+
+  # @yield [value, index]
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_value_with_index
+    return to_enum(__method__) unless block_given?
+    each_value.with_index{|value, index|yield value, index}
+    self
+  end
+  
+  alias_method :each_with_index, :each_value_with_index
+  
+  # @yield [name, value, index]
+  # @yieldparam [Symbol] name
+  # @yieldparam [Integer] index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_pair_with_index
+    return to_enum(__method__) unless block_given?
+    index = 0
+    each_pair do |name, value|
+      yield name, value, index
+      index += 1
+    end
+    self
+  end
+  
+  # @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
+  
+  # @return [Struct]
+  def to_struct
+    self.class.to_struct_class.new(*values)
+  end
+
+  # @endgroup
+end; end

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

@@ -1,4 +1,4 @@
-class Striuct; module Subclassable
+class Striuct; module Containable
   # @group HashLike
   
   # @return [Hash]

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

@@ -1,11 +1,11 @@
-class Striuct; module Subclassable
+class Striuct; module Containable
   private
   
   # @group Use Only Inner
   
   # see self.class.*args
   delegate_class_methods(
-    :keyable_for, :flavor_for, :conditions_for, :originalkey_for
+    :keyable_for, :flavor_for, :condition_for, :originalkey_for
   )
   
   def initialize_copy(original)
@@ -14,8 +14,14 @@ class Striuct; module Subclassable
 
   def __get__(name)
     name = originalkey_for(keyable_for name)
+    value = @db[name]
+  
+    if safety_getter?(name) and !accept?(name, value)
+      raise ConditionError,
+            "#{value.inspect} is deficient for #{name} in #{self.class}"
+    end
 
-    @db[name]
+    value
   end
 
   def __set__(name, value)
@@ -23,13 +29,17 @@ class Striuct; module Subclassable
     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)
+      begin
+        value = instance_exec value, &flavor_for(name)
+      rescue Exception
+        raise ConditionError
+      end
+    end
+
+    if safety_setter?(name) and !accept?(name, value)
+      raise ConditionError,
+            "#{value.inspect} is deficient for #{name} in #{self.class}"
     end
 
     if inference? name
@@ -89,7 +99,9 @@ class Striuct; module Subclassable
       if has_default? name
         self[name] = (
           if (value = default_for name).kind_of? SpecificContainer
-            value.value.call self, name
+            block = value.value
+            args = [self, name][0, block.arity]
+            block.call(*args)
           else
             value
           end
@@ -105,4 +117,4 @@ class Striuct; module Subclassable
   end
   
   # @endgroup
-end; end
+end; end

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

@@ -1,14 +1,33 @@
-class Striuct; module Subclassable
+class Striuct; module Containable
   # @group Struct+ Safety
   
   # see self.class.*args
-  delegate_class_methods :restrict?, :has_conditions?, :inference?
-  
+  delegate_class_methods :restrict?, :has_condition?,
+    :safety_getter?, :safety_reader?, :safety_setter?, :safty_writer?, :inference?
+
+  # @param [Object] value
+  # @param [Proc, Method, #===] condition
+  def pass?(value, condition)
+    case condition
+    when Conditions::ANYTHING
+      true
+    when Proc
+      instance_exec value, &condition
+    when Method
+      condition.call value
+    else
+      condition === value
+    end ? true : false
+  end
+
   # @param [Symbol, String] name
-  # @param [Object] *values - no argument and use own
+  # @param [Object] value - no argument and use own
   # passed under any condition
   def sufficient?(name, value=self[name])
-    self.class.sufficient? name, value, self
+    name = originalkey_for(keyable_for name)
+    return true unless restrict? name
+    
+    pass? value, condition_for(name)
   end
   
   alias_method :accept?, :sufficient?

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

@@ -1,6 +1,6 @@
 autoload :YAML, 'yaml'
 
-class Striuct; module Subclassable
+class Striuct; module Containable
   # @group for YAML
 
   # @return [String]

data/lib/striuct/containable.rb

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

data/lib/striuct/flavors.rb

@@ -0,0 +1,83 @@
+class Striuct
+
+  # Useful Flavor Builders
+  # @author Kenichi Kamiya
+  # @example overview
+  #   class MyClass < Striuct
+  #     member :id, &WHEN(String, PARSE(Integer))
+  module Flavors
+    module_function
+
+    # true if argument is sufficient for flavor.
+    # A flavor have to be arity equal 1.
+    # @param [Object] flavor
+    def adjustable?(flavor)
+      case flavor
+      when Proc
+        flavor.arity == 1
+      else
+        if flavor.respond_to?(:to_proc)
+          flavor.to_proc.arity == 1
+        else
+          false
+        end
+      end
+    end
+    
+    alias_method :flavorable?, :adjustable?
+    
+    # Apply flavor when passed condition.
+    # @return [lambda]
+    def WHEN(condition, flavor)
+      raise TypeError, 'wrong object for condition' unless conditionable? condition
+      raise TypeError, 'wrong object for flavor' unless adjustable? flavor
+      
+      ->v{pass?(v, condition) ? flavor.call(v) : v}
+    end
+    
+    # Sequencial apply all flavors.
+    # @return [lambda]
+    def REDUCE(flavor1, flavor2, *flavors)
+      flavors = [flavor1, flavor2, *flavors]
+
+      unless flavors.all?{|f|adjustable? f}
+        raise TypeError, 'wrong object for flavor'
+      end
+
+      ->v{
+        flavors.reduce(v){|ret, flavor|flavor.call ret}
+      }
+    end
+    
+    alias_method :FLAVORS, :REDUCE
+    alias_method :INJECT, :REDUCE
+
+    # Accept any parser when that resopond to parse method.
+    # @return [lambda]
+    def PARSE(parser)
+      if !::Integer.equal?(parser) and !parser.respond_to?(:parse)
+        raise TypeError, 'wrong object for parser'
+      end
+      
+      ->v{
+        if ::Integer.equal? parser
+          ::Kernel.Integer v
+        else
+          parser.parse(
+            case v
+            when String
+              v
+            when ->_{v.respond_to? :to_str}
+              v.to_str
+            when ->_{v.respond_to? :read}
+              v.read            
+            else
+              raise TypeError, 'wrong object for parsing source'
+            end
+          )
+        end
+      }
+    end
+  end
+
+end

data/lib/striuct/version.rb

@@ -1,4 +1,4 @@
 class Striuct
-  VERSION = '0.1.7'.freeze
+  VERSION = '0.2.3'.freeze
   Version = VERSION
-end
+end

data/lib/striuct.rb

@@ -1,5 +1,16 @@
 # Copyright (C) 2011  Kenichi Kamiya
+# Striuct
+#   Provides a Struct++ class.
 
-require_relative 'striuct/frame'
+# @author Kenichi Kamiya
+# @abstract
+class Striuct
+  class ConditionError < ArgumentError; end
+  
+  # namespace for .to_struct_class, #to_struct
+  module Structs
+  end
+end
 
-StrictStruct = Striuct
+require_relative 'striuct/version'
+require_relative 'striuct/abstract'