striuct 0.0.11.1

data/example.rb

@@ -0,0 +1,214 @@
+#/usr/bin/ruby -w
+
+require_relative 'lib/striuct'
+
+def debug(message)
+  puts "line: #{caller[0].slice(/:(\w+)/, 1)}"
+  puts message.inspect, '-' * 80
+end
+
+#* Macro "member" provides one of Struct+ interfaces for condtions and a flavor.
+class User < Striuct.new
+  member :id, Integer
+  member :address, /\A((\w+) ?)+\z/
+  member :age, (20..140)
+  member :name, /\A\w+\z/, /\A\w+ \w+\z/
+end
+
+# pass
+user = User.new 128381, 'Tokyo Japan', 20
+debug user
+
+# pass
+user.age = 30
+user.name = 'taro yamada'
+debug user
+
+# fail (Exception  Striuct::ConditionError)
+begin
+  user[:id] = 10.0
+rescue
+  debug $!
+end
+
+begin
+  user[1] = 'Tokyo-to'
+rescue
+  debug $!
+end
+
+begin
+  user.age = 19
+rescue
+  debug $!
+end
+
+begin
+  user.name = nil
+rescue
+  debug $!
+end
+
+#* but, linked objects are able to clash
+debug user
+debug user.strict?
+debug user
+debug user.strict?
+
+# more detail checker do you need, you can use functional object.
+module Game
+  class Character
+  end
+
+  class DB < Striuct.new
+    member :monsters, ->monsters{(monsters - characters).empty?}
+    member :characters, ->characters{characters.all?{|c|c.kind_of? Character}}
+  end
+  
+  monster = Character.new
+  db = DB.new
+  
+  begin
+    db.characters = [1, 2]
+  rescue
+    debug $!
+  end
+  
+  db.characters = [monster, Character.new]
+  debug db
+  
+  begin
+    db.monsters = [:dummy]
+  rescue
+    debug $!
+  end
+  
+  db.monsters = [monster]
+  debug db
+end
+
+# "inference", check under first passed object's class
+class FlexibleContainer < Striuct.new
+  member :anything, inference
+  member :number, inference, Numeric
+end
+
+fc1, fc2 = FlexibleContainer.new, FlexibleContainer.new
+fc1.anything = 'str'
+debug fc1
+begin
+  fc1.anything = :sym
+rescue
+  debug $!
+end
+
+begin
+  fc2.anything = :sym
+rescue
+  debug $!
+end
+
+fc2.anything = 'string too'
+
+debug fc2
+
+begin
+  fc1.number = 'str'
+rescue
+  debug $!
+end
+
+fc1.number = 1.0
+debug fc1
+
+begin
+  fc2.number = 1
+rescue
+  debug $!
+end
+
+ 
+# with flavor for type cast
+class User2 < Striuct.new
+  member :age, /\A\d+\z/, Numeric do |arg|
+    Integer arg
+  end
+  
+  member :name, ->v{v.respond_to? :to_str} do |v|
+    v.to_str.to_sym
+  end
+end
+
+user2 = User2.new
+user2.age = 9
+debug user2
+
+user2.age = 10.1
+debug user2
+
+user2.age = '10'
+debug user2
+
+begin
+  user2.name = 10
+rescue
+  debug $!
+end
+
+user2.name = 's'
+debug user2.class
+
+# use default value
+class User3 < Striuct.new
+  member  :lank, Fixnum
+  default :lank, 3
+  member  :name
+end
+
+user3 = User3.new
+user3
+debug user3
+
+# Standard Struct always define "nil is default". ...realy?
+debug user3.assign?(:name)
+user3.name = nil
+debug user3.assign?(:name)
+
+# Standard Struct no check member name. 
+NoGuard = Struct.new :__send__, :'?  !'
+noguard = NoGuard.new false
+debug noguard.__send__
+debug noguard.methods.include?(:'?  !') # lost!!
+
+# Striuct provides safety levels for naming.
+class SafetyNaming < Striuct.new
+  begin
+    member :__send__
+  rescue
+    debug $!
+  end
+  
+  begin
+    member :'?  !'
+  rescue
+    debug $!
+  end
+  
+  # set lower
+  protect_level :struct
+  
+  member :__send__, :'?  !'
+end
+
+
+# and keeping Struct's good interface
+Sth1 = Striuct.new :id, :last_name, :family_name, :address, :age
+
+debug Sth1.new
+
+Sth2 = Striuct.new do
+  def my_special_method
+  end
+end
+
+debug Sth2.new.respond_to?(:my_special_method)

data/lib/striuct/classutil.rb

@@ -0,0 +1,26 @@
+class Striuct
+
+
+# @author Kenichi Kamiya
+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
+    
+    names.each{|name|delegate_class_method name}
+  end
+
+end
+
+
+end

data/lib/striuct/core.rb

@@ -0,0 +1,56 @@
+# Copyright (C) 2011  Kenichi Kamiya
+
+require_relative 'subclass_eigen'
+require_relative 'subclass'
+
+# @author Kenichi Kamiya
+class Striuct
+
+  class ConditionError < ArgumentError; end
+
+  class << self
+    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
+      arg1 = names.first
+      if arg1.instance_of?(String) and /\A[A-Z]/ =~ arg1
+        warn "no define constant #{arg1}"
+      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
+
+    private
+    
+    def inherited(subclass)
+      subclass.class_eval do
+        extend Subclass::Eigen
+        include Subclass
+      end
+    end
+  end
+
+end

data/lib/striuct/import.rb

@@ -0,0 +1,95 @@
+class Striuct
+
+# @author Kenichi Kamiya
+module StructExtension
+
+  module Eigen
+    def has_member?(name)
+      members.include? name
+    end
+
+    alias_method :member?, :has_member?
+    alias_method :has_key?, :has_member?
+    alias_method :key?, :has_key?
+
+    def has_condition?(name)
+      false
+    end
+    
+    alias_method :restrict?, :has_condition?
+
+    def conditionable?(condition)
+      false
+    end
+    
+    def sufficent?(name, value)
+      true
+    end
+    
+    alias_method :accept?, :sufficent?
+
+    def has_default?(name)
+      false
+    end
+    
+    def cname?(name)
+      [Symbol, String].any?{|klass|name.instance_of? klass}
+    end
+
+    def has_flavor?(name)
+      false
+    end
+
+    # @return [Struct]
+    def load_pairs(pairs)
+      raise TypeError, 'no pairs object' unless pairs.respond_to? :each_pair
+
+      new.tap do |r|
+        pairs.each_pair do |name, value|
+          if member? name
+            r[name] = value
+          else
+            raise ArgumentError, " #{name} is not our member"
+          end
+        end
+      end
+    end
+    
+    def define(lock=false)
+      raise ArgumentError unless lock.equal?(false)
+
+      new.tap{|instance|yield instance}
+    end
+
+    # @return [StrictStruct]
+    def to_strict
+      StrictStruct.new(*members)
+    end
+    
+    def closed?
+      true
+    end
+  end
+
+  def assign?(name)
+    ! self[name].nil?
+  end
+
+  def strict?
+    false
+  end
+
+  def secure?
+    false
+  end
+
+end
+
+
+end
+
+
+class Struct
+  extend Striuct::StructExtension::Eigen
+  include Striuct::StructExtension
+end

data/lib/striuct/subclass.rb

@@ -0,0 +1,262 @@
+require_relative 'classutil'
+
+class Striuct
+
+
+# @author Kenichi Kamiya
+module Subclass
+
+  extend ClassUtil
+  include Enumerable
+  
+  def initialize(*values)
+    @db = {}
+    
+    if values.size <= size
+      values.each_with_index do |v, idx|
+        self[idx] = v
+      end
+      
+      excess = members.last(size - values.size)
+      
+      excess.each do |name|
+        self[name] = default_for name if has_default? name
+      end
+    else
+      raise ArgumentError, "struct size differs (max: #{size})"
+    end
+  end
+  
+  # @return [Boolean]
+  def ==(other)
+    if self.class.equal? other.class
+      each_pair.all?{|k, v|v == other[k]}
+    else
+      false
+    end
+  end
+  
+  def eql?(other)
+    if self.class.equal? other.class
+      each_pair.all?{|k, v|v.eql? other[k]}
+    else
+      false
+    end
+  end
+  
+  # @return [Integer]
+  def hash
+    values.map(&:hash).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
+
+  delegate_class_methods(
+    :members, :keys, :has_member?, :member?, :has_key?, :key?, :length,
+    :size, :keyable_for, :restrict?, :has_default?, :default_for,
+    :names, :has_flavor?, :flavor_for, :has_conditions?, :inference?
+  )
+  
+  private :keyable_for, :flavor_for
+  
+  # @param [Symbol, String, Fixnum] key
+  def [](key)
+    __subscript__(key){|name|__get__ name}
+  end
+  
+  # @param [Symbol, String, Fixnum] key
+  # @param [Object] value
+  def []=(key, value)
+    __subscript__(key){|name|__set__ name, value}
+  end
+
+  # @yield [name] 
+  # @yieldparam [Symbol] name - sequential under defined
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_name
+    return to_enum(__method__) unless block_given?
+    self.class.each_name{|name|yield name}
+    self
+  end
+
+  alias_method :each_member, :each_name
+  alias_method :each_key, :each_name
+
+  # @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 (see #each_name)
+  # @yieldparam [Object] value (see #each_value)
+  # @yieldreturn [self]
+  # @return [Enumerator]
+  def each_pair
+    return to_enum(__method__) unless block_given?
+    each_name{|name|yield name, self[name]}
+  end
+
+  # @return [Array]
+  def values
+    [].tap do |r|
+      each_value do |v|
+        r << v
+      end
+    end
+  end
+  
+  alias_method :to_a, :values
+
+  # @param [Fixnum, Range] *keys
+  # @return [Array]
+  def values_at(*keys)
+    [].tap do |r|
+      keys.each do |key|
+        case key
+        when Fixnum
+          r << self[key]
+        when Range
+          key.each do |n|
+            r << self[n]
+          end
+        else
+          raise TypeError
+        end
+      end
+    end
+  end
+
+  # @param [Symbol, String] name
+  def assign?(name)
+    name = keyable_for name
+    raise NameError unless member? name
+    
+    @db.has_key? name
+  end
+
+  # @param [Symbol, String] name
+  def unassign(name)
+    raise "can't modify frozen #{self.class}" if frozen?
+    name = keyable_for name
+    raise NameError unless member? name
+    
+    @db.delete name
+  end
+  
+  # @param [Symbol, String] name
+  # @param [Object] *values - no argument and use own
+  def sufficent?(name, value=self[name])
+    self.class.__send__(__method__, name, value, self)
+  end
+  
+  alias_method :accept?, :sufficent?
+
+  def strict?
+    each_pair.all?{|name, value|self.class.sufficent? name, value}
+  end
+  
+  def secure?
+    frozen? && self.class.closed? && strict?
+  end
+  
+  # @return [self]
+  def freeze
+    @db.freeze
+    super
+  end
+  
+  # @param [Symbol, String] name
+  def default?(name)
+    default_for(name) == self[name]
+  end
+
+  private
+  
+  def initialize_copy(org)
+    @db = @db.clone
+  end
+
+  def __get__(name)
+    name = keyable_for name
+    raise NameError unless member? name
+
+    @db[name]
+  end
+
+  def __set__(name, value)
+    raise "can't modify frozen #{self.class}" if frozen?
+    name = keyable_for name
+    raise NameError unless member? name
+
+    if accept? name, value
+      if has_flavor? name
+        value = instance_exec value, &flavor_for(name)
+      end
+
+      if inference? name
+        self.class.__send__ :__found_family__!, name, value
+      end
+      
+      @db[name] = value
+    else
+      raise ConditionError, 'deficent value for all conditions'
+    end
+  end
+  
+  alias_method :assign, :__set__
+  public :assign
+  
+  def __subscript__(key)
+    case key
+    when Symbol, String
+      name = keyable_for key
+      if member? name
+        yield name
+      else
+        raise NameError
+      end
+    when Fixnum
+      if name = members[key]
+        yield name
+      else
+        raise IndexError
+      end
+    else
+      raise ArgumentError
+    end
+  end
+
+
+end
+
+
+end