striuct 0.1.7 → 0.2.3

data/example/example.old.rdoc

@@ -0,0 +1,188 @@
+=== Struct+ "Safety"
+
+==== "member" macro
+
+* Use "member" and you get a accessor, it looks Struct with tester(validator)s. 
+    class User < Striuct.new
+      member :id,   Integer
+      member :age,  (20..140)
+      member :name, OR(/\A\w+\z/, /\A\w+ \w+\z/)
+    end
+
+    # pass
+    user = User.new 128381, 20
+    user.age = 30
+    user[2] = 'foo bar'
+
+    # fail
+    user[:id] = 10.0
+    user.age = 19
+    user[2] = nil
+
+* Use functional object and you get a tester on upstairs.
+    module Game
+      class Character
+      end
+
+      class DB < Striuct.new
+        member :monsters,   ->list{(list - characters).empty?}
+        member :characters, GENERICS(Character)
+      end
+      
+      monster = Character.new
+      db = DB.new
+      
+      # fail
+      db.characters = [1, 2]
+      
+      # pass
+      db.characters = [monster, Character.new]
+      
+      # fail
+      db.monsters = [Character.new]
+      
+      # pass
+      db.monsters = [monster]
+    end
+
+* Use "inference" and all instance test under class of first passed object.
+    class FlexibleContainer < Striuct.new
+      member :anything, anything, inference: true
+      member :number, Numeric, inference: true
+    end
+
+    fc1, fc2 = FlexibleContainer.new, FlexibleContainer.new
+    # pass
+    fc1.anything = 'str'
+ 
+    # fail
+    fc1.anything = :sym
+    fc2.anything = :sym
+    
+    # pass
+    fc2.anything = 'string too'
+    
+    # fail
+    fc1.number = 'str'
+    
+    # pass
+    fc1.number = 1.0
+
+    # fail
+    fc2.number = 1
+
+==== Protect from risks in naming members
+
+* Standard Struct dosen't check member-name. 
+    NoGuard = Struct.new :object_id, :'?  !'
+    noguard = NoGuard.new false
+    noguard.object_id #=> false
+    noguard.methods.include?(:'?  !') #=> false(lost!!)
+
+* Striuct provides safety levels for this. (default: :prevent)
+    class SafetyNaming < Striuct.new
+      begin
+        member :object_id
+      rescue
+        p $!
+      end
+      
+      begin
+        member :'?  !'
+      rescue
+        p $!
+      end
+      
+      # set lower
+      protect_level :struct
+      
+      member :object_id, :'?  !'
+    end
+
+=== Struct+ "Handy"
+
+==== Flavor
+
+* Block with member macro, it is called "flavor" at here.
+  Below cases for type cast.
+    class User2 < Striuct.new
+      member :age, Fixnum, &->v{Integer v}
+      member :name, Symbol, &->v{v.to_s.to_sym}
+    end
+    
+    user2 = User2.new
+    user2.age = 9 #=> 9(Fixnum)
+    user2.age = 10.1 #=> 10(Fixnum)
+    user2.age = '10' #=> 10(Fixnum)
+
+    user2.name = 10 #=> :10(Symbol)
+    user2.name = Class #=> :Class(Symbol)
+
+==== Default
+
+* provides default value and can use block parameter(like Hash.new)
+    class User3 < Striuct.new
+      member  :lank, Fixnum
+      default :lank, 3
+      member  :name
+    end
+    
+    user3 = User3.new
+    user3.lank #=> 3
+    
+* Standard Struct always define "nil is default". Realy?
+    user3.name  #=> nil
+    user3.assign? :name #=> false
+    user3.name = nil
+    user3.assign? :name #=> true
+
+==== Alias
+
+* alias member name
+    class User3
+      alias_member :position, :lank
+    end
+    
+    user3.lank.equal? user3.position #=> true
+    user3[:lank].equal? user3[:position] #=> true
+    user3[:position] = 4
+    user3.lank  #=> 4
+
+==== Inherit
+
+* (writing...)
+
+==== Lock
+
+* (writing...)
+
+==== New Constructors
+
+* Subclass.define reject floating object.
+  * block parameter is new instance
+  * except if no finished to assign each member
+  * returning object is tested strict(optional)
+  * returning object is locked(optional)
+      user3 = User3.define do |r|
+        r.lank = 10
+        r.name = 'foo'
+      end
+
+* Subclass.[](load_pairs) make from Hash and like Hash
+    user3 = User3[lank: 10, name: 'foo']
+
+=== Almost interfaces are keeping Struct has.
+
+    Sth1 = Striuct.new do
+      def my_special_method
+      end
+    end
+    
+    Sth1.new.respond_to?(:my_special_method) #=> true
+
+=== HashLike
+
+* some interfaces import from Hash
+
+* easy cast to Hash
+    user3.to_h #=> {:lank=>3, :name=>nil}

data/example/example.rb

@@ -1,225 +1,17 @@
-#/usr/bin/ruby -w
+$VERBOSE = true
 
-require_relative '../lib/striuct'
+require '../lib/striuct'
 
-def debug(message)
-  puts "line: #{caller.first.slice(/:(\w+)/, 1)}"
-  puts message.inspect, '-' * 80
+Person = Striuct.define do
+  member :name, AND(String, /\A\w+( \w+)?\z/)
 end
 
-
-# 1. Struct+ "Secure"
-
-# macro "member" provides to use condtions
-class User < Striuct.new
-  member :id,   Integer
-  member :age,  (20..140)
-  member :name, OR(/\A\w+\z/, /\A\w+ \w+\z/)
-end
-
-user = User.new 128381, 20
-debug user
-
-user.age = 30
-user[2] = 'taro yamada'
-debug user
-
-# fail (Exception  Striuct::ConditionError)
-begin
-  user[:id] = 10.0
-rescue
-  debug $!
-end
-
-begin
-  user.age = 19
-rescue
-  debug $!
-end
-
-begin
-  user[2] = 'typo! name'
-rescue
-  debug $!
-end
-
-# more detail checker do you need, use functional object
-module Game
-  class Character
-  end
-
-  class DB < Striuct.new
-    member :monsters,   ->list{(list - characters).empty?}
-    member :characters, GENERICS(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 = [Character.new]
-  rescue
-    debug $!
-  end
-  
-  db.monsters = [monster]
-  debug db
-end
-
-# through "inference", and check under first passed object class
-class FlexibleContainer < Striuct.new
-  member :anything, inference
-  member :number,   Numeric, inference
-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
-
-# Standard Struct not 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
-
-# 2. Struct+ "Handy"
-
-# to through block called "flavor"
-# below case 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_s} do |v|
-    v.to_s.to_sym
-  end
-end
-
-user2 = User2.new
-user2.age = 9
-debug user2
-
-user2.age = 10.1
-debug user2
-
-user2.age = '10'
-debug user2
-
-user2.name = 10
-debug user2
-user2.name = Class
-debug user2
-
-# 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)
-
-# Alias
-
-class User3
-  alias_member :position, :lank
-end
-
-debug user3.lank.equal?(user3.position)
-debug user3[:lank].equal?(user3[:position])
-user3[:position] = 4
-debug user3.lank
-
-# New Constructors
-
-# Subclass.define reject floating object
-# * except if no finished assign each members
-# * return object is frozen
-user3 = User3.define do |r|
-  r.lank = 10
-  r.name = 'foo'
-end
-
-debug user3
-
-# Subclass.load_pairs easy make from Hash and like Hash
-user3 = User3[lank:10, name: 'foo']
-
-debug user3
-
-# 3. Keeping Struct's good interface
-
-Sth1 = Striuct.new do
-  def my_special_method
-  end
+class User < Person
+  member :id, AND(Integer, 1..99999)
 end
 
-debug Sth1.new.respond_to?(:my_special_method)
+user = User.new
+p user.members      #=> [:name, :id]
+p user.name = :Ken  #=> error
+p user.name = ''    #=> error
+p user.name = 'Ken' #=> pass

data/example/example1.rb

@@ -0,0 +1,234 @@
+#/usr/bin/ruby -w
+
+require_relative '../lib/striuct'
+
+def debug(message)
+  puts "line: #{caller.first.slice(/:(\w+)/, 1)}"
+  puts message.inspect, '-' * 80
+end
+
+
+# 1. Struct+ "Secure"
+
+# macro "member" provides to use condtions
+class User < Striuct.new
+  member :id,   Integer
+  member :age,  (20..140)
+  member :name, OR(/\A\w+\z/, /\A\w+ \w+\z/)
+end
+
+user = User.new 128381, 20
+debug user
+
+user.age = 30
+user[2] = 'taro yamada'
+debug user
+
+# fail (Exception  Striuct::ConditionError)
+begin
+  user[:id] = 10.0
+rescue
+  debug $!
+end
+
+begin
+  user.age = 19
+rescue
+  debug $!
+end
+
+begin
+  user[2] = 'typo! name'
+rescue
+  debug $!
+end
+
+# more detail checker do you need, use functional object
+module Game
+  class Character
+  end
+
+  class DB < Striuct.new
+    member :monsters,   ->list{(list - characters).empty?}
+    member :characters, GENERICS(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 = [Character.new]
+  rescue
+    debug $!
+  end
+  
+  db.monsters = [monster]
+  debug db
+end
+
+# through "inference", and check under first passed object class
+class FlexibleContainer < Striuct.new
+  member :anything, anything, inference: true
+  member :number,   Numeric, inference: true
+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
+
+# Standard Struct not 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
+
+# 2. Struct+ "Handy"
+
+# to through block called "flavor"
+# below case for type cast
+class User2 < Striuct.new
+  member :age, OR(/\A\d+\z/, Numeric) do |arg|
+    Integer arg
+  end
+  
+  member :name, ->v{v.respond_to? :to_s} do |v|
+    v.to_s.to_sym
+  end
+end
+
+user2 = User2.new
+user2.age = 9
+debug user2
+
+user2.age = 10.1
+debug user2
+
+user2.age = '10'
+debug user2
+
+user2.name = 10
+debug user2
+user2.name = Class
+debug user2
+
+# 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)
+
+# Alias
+
+class User3
+  alias_member :position, :lank
+end
+
+debug user3.lank.equal?(user3.position)
+debug user3[:lank].equal?(user3[:position])
+user3[:position] = 4
+debug user3.lank
+
+# New Constructors
+
+# Subclass.define reject floating object
+# * except if no finished assign each members
+# * return object is frozen
+user3 = User3.define do |r|
+  r.lank = 10
+  r.name = 'foo'
+end
+
+debug user3
+
+# Subclass.load_pairs easy make from Hash and like Hash
+user3 = User3[lank:10, name: 'foo']
+
+debug user3
+
+# 3. Keeping Struct's good interface
+
+Sth1 = Striuct.new do
+  def my_special_method
+  end
+end
+
+debug Sth1.new.respond_to?(:my_special_method)
+
+# to_struct
+MyC = Striuct.new :a, :b
+a =  MyC.to_struct_class
+p a
+
+p MyC.new.to_struct
+myc = Striuct.new :a, :b
+p myc.new.to_struct

data/example/example2.rb

@@ -0,0 +1,22 @@
+#!/usr/local/bin/ruby -w
+
+$VERBOSE = true
+
+require_relative 'lib/striuct'
+
+User = Striuct.define do  # other way "class User < Striuct.new"
+  member :firstname, /\w+/ # look like case syntax in Ruby
+  member :lank, AND(Fixnum, 1..10) # easy build multiple validation
+  default :lank, 3        # set a normal default value
+  member :registered, Time # look like type variable
+  default :registered, &->{Time.now} # evaluate with construction          
+  p members #=> [firstname, lank, registered]
+end
+
+class MyUser < User
+  p members #=> [firstname, lank, registered]
+  member :foo # no validation, just an accessor
+  p members #=> [firstname, lank, registered, :foo]
+end
+
+user = MyUser.new

data/lib/striuct/abstract.rb

@@ -1,4 +1,4 @@
-require_relative 'subclassable/frame'
+require_relative 'containable'
 
 class Striuct; class << self
   # @group Constructor
@@ -46,10 +46,10 @@ class Striuct; class << self
   def inherited(subclass)
     attributes = (
       if equal? ::Striuct
-        [[], {}, {}, {}, {}, {}, :prevent]
+        [[], {}, {}, {}, {}, {}, {}, {}, :prevent]
       else
         [*[@names, @conditions, @flavors, @defaults,\
-        @inferences, @aliases].map(&:dup), @protect_level]
+        @inferences, @aliases, @setter_validations, @getter_validations].map(&:dup), @protect_level]
       end
     )
     
@@ -57,15 +57,15 @@ class Striuct; class << self
 
     subclass.class_eval do
       original_inherited subclass
-      include Subclassable if ::Striuct.equal? eigen
+      include Containable if ::Striuct.equal? eigen
       
       @names, @conditions, @flavors, @defaults,\
-      @inferences, @aliases, @protect_level  = *attributes
+      @inferences, @aliases, @setter_validations, @getter_validations, @protect_level  = *attributes
       
       singleton_class.instance_eval do
         define_method :initialize_copy do |original|
-          @names, @flavors, @defaults, @aliases = 
-          *[@names, @flavors, @defaults, @aliases].map(&:dup)
+          @names, @flavors, @defaults, @aliases, @setter_validations, @getter_validations = 
+          *[@names, @flavors, @defaults, @aliases, @setter_validations, @getter_validations].map(&:dup)
           @conditions, @inferences = @conditions.dup, @inferences.dup
         end
       end