striuct 0.0.11.1 → 0.1.7

data/lib/striuct/abstract.rb

@@ -0,0 +1,74 @@
+require_relative 'subclassable/frame'
+
+class Striuct; class << self
+  # @group Constructor
+  
+  alias_method :new_instance, :new
+  private :new_instance
+  
+  # @param [Symbol, String] *names
+  # @return [Class] - with Subclass, Subclass:Eigen
+  def new(*names, &block)
+    # warning for Ruby's Struct.new user
+    first = names.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
+      end
+
+      class_eval(&block) if block_given?
+    end
+  end
+
+  # @yieldreturn [Class] (see Striuct.new) - reject floating class
+  # @return [void]
+  def define(&block)
+    raise ArgumentError, 'must with block' unless block_given?
+
+    new(&block).tap do |subclass|
+      subclass.instance_eval do
+        raise 'not yet finished' if members.empty?
+        close
+      end
+    end
+  end
+
+  # @groupend
+
+  private
+  
+  alias_method :original_inherited, :inherited
+  
+  def inherited(subclass)
+    attributes = (
+      if equal? ::Striuct
+        [[], {}, {}, {}, {}, {}, :prevent]
+      else
+        [*[@names, @conditions, @flavors, @defaults,\
+        @inferences, @aliases].map(&:dup), @protect_level]
+      end
+    )
+    
+    eigen = self
+
+    subclass.class_eval do
+      original_inherited subclass
+      include Subclassable if ::Striuct.equal? eigen
+      
+      @names, @conditions, @flavors, @defaults,\
+      @inferences, @aliases, @protect_level  = *attributes
+      
+      singleton_class.instance_eval do
+        define_method :initialize_copy do |original|
+          @names, @flavors, @defaults, @aliases = 
+          *[@names, @flavors, @defaults, @aliases].map(&:dup)
+          @conditions, @inferences = @conditions.dup, @inferences.dup
+        end
+      end
+    end
+  end
+end; end

data/lib/striuct/conditions.rb

@@ -0,0 +1,228 @@
+class Striuct
+
+  # Useful Condition Patterns
+  module Conditions
+    module_function
+
+    # @param [Object] condition
+    def conditionable?(condition)
+      case condition
+      when Proc, Method
+        condition.arity == 1
+      else
+        condition.respond_to? :===
+      end
+    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
+
+      case condition
+      when Proc
+        if context
+          context.instance_exec value, &condition
+        else
+          condition.call value
+        end
+      when Method
+        condition.call value
+      else
+        condition === value
+      end ? true : false
+    end
+
+    # @return [lambda] 
+    def NOT(condition)
+      unless conditionable? condition
+        raise TypeError, 'wrong object for condition'
+      end
+      
+      ->v{! self.class.__send__(:pass?, v, condition, self)}
+    end
+
+    # @return [lambda] 
+    def _logical_operator(delegated, *conditions)
+      unless conditions.all?{|c|conditionable? c}
+        raise TypeError, 'wrong object for condition'
+      end
+      
+      ->v{
+        conditions.__send__(delegated) {|condition|
+          self.class.__send__(:pass?, v, condition, self)
+        }
+      }
+    end
+
+    # @return [lambda] check "match all conditions"
+    def AND(cond1, cond2, *conds)
+      _logical_operator :all?, cond1, cond2, *conds
+    end
+    
+    alias_method :ALL, :AND
+    module_function :ALL
+  
+    # @return [lambda] 
+    def NAND(cond1, cond2, *conds)
+      ! AND(cond1, cond2, *conds)
+    end
+
+    # @return [lambda] check "match any condition"
+    def OR(cond1, cond2, *conds)
+      _logical_operator :any?, cond1, cond2, *conds
+    end
+
+    alias_method :ANY, :OR
+    module_function :ANY
+
+    # @return [lambda] 
+    def NOR(cond1, cond2, *conds)
+      ! OR(cond1, cond2, *conds)
+    end
+
+    # @return [lambda] 
+    def XOR(cond1, cond2, *conds)
+      _logical_operator :one?, cond1, cond2, *conds
+    end
+    
+    alias_method :ONE, :XOR
+    module_function :ONE
+
+    # @return [lambda] 
+    def XNOR(cond1, cond2, *conds)
+      ! XOR(cond1, cond2, *conds)
+    end
+
+    # @return [lambda] use #==
+    def EQUAL(obj)
+      ->v{obj == v}
+    end
+    
+    # @return [lambda] use #equal?
+    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'
+      end
+      
+      ->v{
+        names.all?{|name|v.respond_to? name}
+      }
+    end
+
+    alias_method :CAN, :RESPONSIBLE
+    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
+    def NO_RAISES(condition1, *conditions)
+      conditions = [condition1, *conditions]
+      unless conditions.all?{|c|conditionable? c}
+        raise TypeError, 'wrong object for condition'
+      end
+      
+      ->v{
+        conditions.all?{|condition|
+          begin
+            self.class.__send__(:pass?, v, condition, self)
+          rescue Exception
+            false
+          else
+            true
+          end
+        }
+      }
+    end
+    
+    alias_method :STILL, :NO_RAISES
+    module_function :STILL
+    
+    # @return [lambda] true when catch the exception
+    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)
+        rescue exception
+          true
+        rescue Exception
+          false
+        else
+          false
+        end
+      }
+    end
+    
+    alias_method :RESCUE, :CATCH
+    module_function :RESCUE
+
+    # @return [lambda] check "all included objects match any conditions"
+    def GENERICS(condition1, *conditions)
+      conditions = [condition1, *conditions]
+      unless conditions.all?{|c|conditionable? c}
+        raise TypeError, 'wrong object for condition'
+      end
+      
+      ->list{
+        conditions.all?{|condition|
+          (list.respond_to?(:each_value) ? list.each_value : list.each).all?{|v|
+            self.class.__send__(:pass?, v, condition, self)
+          }
+        }
+      }
+    end
+    
+    alias_method :generics, :GENERICS
+    module_function :generics
+
+    # @return [lambda]
+    def MEMBER_OF(list1, *lists)
+      lists = [list1, *lists]
+      unless lists.all?{|l|l.respond_to? :all?}
+        raise TypeError, 'list must respond #all?'
+      end
+      
+      ->v{
+        lists.all?{|list|list.include? v}
+      }
+    end
+    
+    alias_method :member_of, :MEMBER_OF
+    module_function :member_of
+    
+    BOOLEAN = OR(SAME(true), SAME(false))
+
+    # @return [BOOLEAN] "true or false"
+    def boolean
+      BOOLEAN
+    end
+
+    alias_method :bool, :boolean
+    module_function :bool
+
+    STRINGABLE = OR(String, Symbol, CAN(:to_str), CAN(:to_sym))
+
+    # @return [STRINGABLE] check "looks string family"
+    def stringable
+      STRINGABLE
+    end
+    
+    class << self
+      private :_logical_operator
+    end
+  end
+
+end

data/lib/striuct/frame.rb

@@ -0,0 +1,8 @@
+# @author Kenichi Kamiya
+# @abstract
+class Striuct
+  class ConditionError < ArgumentError; end
+end
+
+require_relative 'version'
+require_relative 'abstract'

data/lib/striuct/subclassable/basic.rb

@@ -0,0 +1,135 @@
+class Striuct; module Subclassable
+  # @group Basic
+  
+  def initialize(*values)
+    @db, @locks = {}, {}
+    replace_values(*values)
+  end
+
+  # see self.class.*args
+  delegate_class_methods(
+    :members, :keys, :names,
+    :has_member?, :member?, :has_key?, :key?,
+    :length, :size
+  )
+  
+  # @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
+  
+  # @return [String]
+  def inspect
+    "#<#{self.class} (StrictStruct)".tap do |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|
+      each_pair do |name, value|
+        s << " #{name}=#{value.inspect}"
+      end
+      
+      s << '>'
+    end
+  end
+
+  # @param [Symbol, String, Fixnum] key
+  def [](key)
+    __subscript__(key){|name|__get__ name}
+  end
+  
+  # @param [Symbol, String, Fixnum] key
+  # @param [Object] value
+  # @return [value]
+  def []=(key, value)
+    true_name = nil
+    __subscript__(key){|name|true_name = name; __set__ name, value}
+  rescue ConditionError
+    $@ = [
+      "#{$@[-1].sub(/[^:]+\z/){''}}in `[#{key}(#{true_name})]=': #{$!.message}",
+      $@[-1]
+    ]
+
+    raise
+  end
+
+  alias_method :assign, :[]
+
+  # @yield [value]
+  # @yieldparam [Object] value - sequential under defined
+  # @see #each_name
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_value
+    return to_enum(__method__) unless block_given?
+    each_member{|member|yield self[member]}
+  end
+  
+  alias_method :each, :each_value
+
+  # @yield [name, value]
+  # @yieldparam [Symbol] name
+  # @yieldparam [Object] value
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  # @see #each_name
+  # @see #each_value 
+  def each_pair
+    return to_enum(__method__) unless block_given?
+    each_name{|name|yield name, self[name]}
+  end
+
+  # @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 freeze
+    [@db, @locks].each(&:freeze)
+    super
+  end
+
+  # @endgroup
+end; end

data/lib/striuct/{classutil.rb → subclassable/classutil.rb}

@@ -1,4 +1,4 @@
-class Striuct
+class Striuct; module Subclassable
 
 
 # @author Kenichi Kamiya
@@ -6,16 +6,16 @@ module ClassUtil
 
   private
   
-  # @macro delegate_class_method
   def delegate_class_method(name)
     define_method name do |*args, &block|
       self.class.__send__ name, *args, &block
     end
   end
   
-  # @macro delegate_class_methods
   def delegate_class_methods(*names)
-    raise ArgumentError, 'wrong number of argument 0 for 1+' unless names.length >= 1
+    unless names.length >= 1
+      raise ArgumentError, 'wrong number of argument 0 for 1+'
+    end
     
     names.each{|name|delegate_class_method name}
   end
@@ -23,4 +23,4 @@ module ClassUtil
 end
 
 
-end
+end; end

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

@@ -0,0 +1,38 @@
+class Striuct; module Subclassable; module Eigen
+  # @group Basic
+
+  # @return [Array<Symbol>]
+  def names
+    @names.dup
+  end
+
+  alias_method :members, :names
+  alias_method :keys, :names
+
+  def has_member?(name)
+    originalkey_for(keyable_for name)
+  rescue Exception
+    false
+  else
+    true
+  end
+  
+  alias_method :member?, :has_member?
+  alias_method :has_key?, :has_member?
+  alias_method :key?, :has_key?
+
+  # @return [Integer]
+  def length
+    @names.length
+  end
+  
+  alias_method :size, :length
+
+  # @return [self]
+  def freeze
+    __stores__.each(&:freeze)
+    super
+  end
+
+  # @endgroup
+end; end; end

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

@@ -0,0 +1,58 @@
+class Striuct; module Subclassable; module Eigen
+  # @group Constructor
+  
+  # @return [Subclass]
+  def load_values(*values)
+    new_instance(*values)
+  end
+
+  alias_method :new, :load_values
+
+  # @param [#each_pair, #keys] pairs ex: Hash, Struct
+  # @return [Subclass]
+  def load_pairs(pairs)
+    unless pairs.respond_to?(:each_pair) and pairs.respond_to?(:keys)
+      raise TypeError, 'no pairs object'
+    end
+
+    raise ArgumentError, "different members" unless (pairs.keys - keys).empty?
+
+    new.tap {|instance|
+      pairs.each_pair do |name, value|
+        instance[name] = value
+      end
+    }
+  end
+
+  alias_method :[], :load_pairs
+
+  # @yieldparam [Subclass] instance
+  # @yieldreturn [Subclass] instance
+  # @return [void]
+  # for build the fixed object
+  def define(options={lock: true, strict: true})
+    raise TypeError, 'arguments have to be pairs object' unless options.respond_to? :keys
+    raise ArgumentError, 'Unknown parameters' unless (options.keys - [:lock, :strict]).empty?
+    raise ArgumentError, 'must with block' unless block_given?
+    
+    lock, strict = options[:lock], options[:strict]
+    
+    new.tap {|instance|
+      yield instance
+  
+      unless (yets = each_name.select{|name|! instance.assign?(name)}).empty?
+        raise "not assigned members are, yet '#{yets.inspect} in #{self}'"
+      end
+      
+      if strict &&
+        ! (invalids = each_name.select{|name|! instance.valid?(name)}).empty?
+
+        raise ConditionError, "invalids members are, yet '#{invalids.inspect} in #{self}'"
+      end
+
+      instance.lock if lock
+    }
+  end
+
+  # @endgroup
+end; end; end

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

@@ -0,0 +1,39 @@
+require_relative '../../conditions'
+
+class Striuct; module Subclassable
+
+# @author Kenichi Kamiya
+module Eigen  
+  include Conditions
+  
+  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
+  
+  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'

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

@@ -0,0 +1,92 @@
+class Striuct; module Subclassable; module Eigen
+  # @group Struct+ Handy
+
+  # @yield [name] 
+  # @yieldparam [Symbol] name - sequential under defined
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_name(&block)
+    return to_enum(__method__) unless block_given?
+    _names.each(&block)
+    self
+  end
+
+  alias_method :each_member, :each_name
+  alias_method :each_key, :each_name
+  
+  # @yield [index] 
+  # @yieldparam [Integer] Index
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_index(&block)
+    return to_enum(__method__) unless block_given?
+    _names.each_index(&block)
+    self
+  end
+  
+  # @param [Symbol, String] name
+  def original?(name)
+    if member? name
+      @names.include? name
+    else
+      raise NameError
+    end
+  end
+  
+  # @param [Symbol, String] name
+  def aliased?(name)
+    if member? name
+      @aliases.has_key? name
+    else
+      raise NameError
+    end
+  end
+  
+  # @param [Symbol, String] original
+  def has_aliases?(original)
+    if original? original
+      @aliases.has_value? original
+    else
+      raise NameError
+    end
+  end
+  
+  # @param [Symbol, String] original
+  # @return [Array<Symbol>]
+  def aliases_for(original)
+    original = keyable_for original
+
+    if has_aliases? original
+      _aliases_for original
+    else
+      raise NameError
+    end
+  end
+
+  # @param [Symbol, String] name
+  def has_flavor?(name)
+    name = originalkey_for(keyable_for name)
+
+    ! flavor_for(name).nil?
+  end
+
+  # @param [Symbol, String] name
+  def has_default?(name)
+    name = originalkey_for(keyable_for name)
+
+    @defaults.has_key? name
+  end
+  
+  # @param [Symbol, String] name
+  def default_for(name)
+    name = originalkey_for(keyable_for name)
+  
+    if has_default? name
+      _default_for name
+    else
+      raise "#{name} has no default value"
+    end
+  end
+
+  # @endgroup
+end; end; end