traits 0.9.0 → 0.9.1

data/lib/traits.rb

@@ -1,5 +1,5 @@
 $__TRAIT_DEBUG__ = ENV['__TRAIT_DEBUG__'] || ENV['TRAIT_DEBUG'] || ENV['DEBUG']
-$__TRAIT_VERSION__ = "0.9.0" 
+$__TRAIT_VERSION__ = "0.9.1" 
 
 class Object
 #--{{{
@@ -670,18 +670,44 @@ end
 
 module TraitInit
 #--{{{
-  def trait_init opts = {}
-#--{{{
-    opts.each do |k,v| 
-      k = "#{ k }"
-      if respond_to? k
-        send k, v
-      else
-        raise ArgumentError, "invalid trait -- #{ self.class }##{ k }"
+  module InstaceMethods
+    def trait_init *argv
+#--{{{
+      args, opts = argv.partition{|arg| not Hash === arg}
+      args.flatten!
+      opts = opts.inject({}){|h,h2| h.update h2}
+      msgs = r_traits
+      args.each{|arg| send msgs.shift, v}
+      opts.each do |k,v| 
+        k = "#{ k }"
+        if respond_to? k
+          send k, v
+        else
+          raise ArgumentError, "invalid trait -- #{ self.class }##{ k }"
+        end
       end
+#--}}}
     end
+    alias_method "traitinit", "trait_init"
+  end
+  module ClassMethods
+    def trait_initialize *a, &b
+      traits *a unless a.empty?
+      module_eval{
+        def initialize(*a, &b)
+          super() if defined? super
+          trait_init *a
+        end
+      }
+    end
+    alias_method "traitinitialize", "trait_initialize"
+  end
+  def self.included other
+#--{{{
+    other.extend ClassMethods
+    other.module_eval{ include InstaceMethods }
+    super
 #--}}}
   end
-  alias_method "traitinit", "trait_init"
 #--}}}
 end

data/sample/a.rb

@@ -0,0 +1,22 @@
+require 'traits'
+#
+# defining a trait is like attr_accessor in the simple case 
+#
+class C
+  trait :t
+end
+
+o = C::new
+o.t = 42
+p o.t
+
+#
+# and can be made even shorter
+# 
+
+class B; has :x; end
+
+o = B::new
+o.x = 42
+p o.x 
+

data/sample/b.rb

@@ -0,0 +1,14 @@
+require 'traits'
+#
+# multiple traits can be defined at once using a list/array of string/sybmol
+# arguments
+#
+class C
+  has :t0, :t1
+  has %w( t2 t3 ) 
+end
+
+obj = C::new
+obj.t0 = 4 
+obj.t3 = 2 
+print obj.t0, obj.t3, "\n"

data/sample/c.rb

@@ -0,0 +1,49 @@
+require 'traits'
+#
+# a hash argument can be used to specify default values
+#
+class C
+  has 'a' => 4, :b => 2 
+end
+
+o = C::new
+print o.a, o.b, "\n"
+
+#
+# and these traits are smartly inherited
+#
+class K < C; end
+
+o = K::new
+o.a = 40
+p( o.a + o.b ) # note that we pick up a default b from C class here since it
+               # has not been set
+
+o.a = 42
+o.b = nil
+p( o.b || o.a ) # but not here since we've explicitly set it to nil
+
+#
+# if a block is specifed as the default the initialization of the default value
+# is deferred until needed which makes for quite natural trait definitions.  the
+# block is passed 'self' so references to the current object can be made. (if
+# this were not done 'self' in the block would be bound to the class!)
+#
+
+class C
+  class << self
+    has('classname'){ name.upcase }
+  end
+
+  has('classname'){ self.class.classname.downcase }
+end
+
+class B < C; end
+
+o = C::new
+p C::classname
+p o.classname
+
+o = B::new
+p B::classname
+p o.classname

data/sample/d.rb

@@ -0,0 +1,30 @@
+require 'traits'
+#
+# all behaviours work within class scope (metal/singleton-class) to define
+# class methods
+#
+class C
+  class << self
+    traits 'a' => 4, 'b' => 2
+  end
+end
+
+print C::a, C::b, "\n"
+
+#
+# singleton methods can even be defined on objects
+#
+
+class << (a = %w[dog cat ostrich])
+  has 'category' => 'pets' 
+end
+p a.category
+
+#
+# and modules
+#
+module Mmmm
+  class << self; trait 'good' => 'bacon'; end 
+end
+
+p Mmmm.good

data/sample/e.rb

@@ -0,0 +1,10 @@
+require 'traits'
+#
+# shorhands exit to enter 'class << self' in order to define class traits
+#
+class C
+  class_trait 'a' => 4
+  c_has :b => 2 
+end
+
+print C::a, C::b, "\n"

data/sample/f.rb

@@ -0,0 +1,25 @@
+require 'traits'
+#
+# as traits are defined they are remembered and can be accessed 
+#
+class C
+  class_trait :first_class_method
+  trait :first_instance_method
+end
+
+class C
+  class_trait :second_class_method
+  trait :second_instance_method
+end
+
+#
+# readers and writers are remembered separatedly
+#
+p C::class_reader_traits 
+p C::instance_writer_traits 
+
+#
+# and can be gotten together at class or instance level
+#
+p C::class_traits
+p C::traits

data/sample/g.rb

@@ -0,0 +1,16 @@
+require 'traits'
+#
+# another neat feature is that they are remembered per hierarchy 
+#
+class C
+  class_traits :base_class_method
+  trait :base_instance_method
+end
+
+class K < C
+  class_traits :derived_class_method
+  trait :derived_instance_method
+end
+
+p C::class_traits 
+p K::class_traits 

data/sample/h.rb

@@ -0,0 +1,17 @@
+require 'traits'
+#
+# a depth first search path is used to find defaults 
+#
+class C
+  has 'a' => 42 
+end
+class K < C; end
+
+k = K::new
+p k.a 
+
+#
+# once assigned this is short-circuited
+#
+k.a = 'forty-two'
+p k.a 

data/sample/i.rb

@@ -0,0 +1,36 @@
+require 'traits'
+#
+# getters and setters can be defined separately 
+#
+class C
+  has_r :r
+end
+class D
+  has_w :w
+end
+
+#
+# defining a reader trait still defines __public__ query and __private__ writer
+# methods
+#
+class C
+  def using_private_writer_and_query
+    p r?
+    self.r = 42
+    p r
+  end
+end
+C::new.using_private_writer_and_query
+
+#
+# defining a writer trait still defines __private__ query and __private__ reader
+# methods
+#
+class D
+  def using_private_reader
+    p w?
+    self.w = 'forty-two' 
+    p w
+  end
+end
+D::new.using_private_reader

data/sample/j.rb

@@ -0,0 +1,23 @@
+require 'traits'
+#
+# getters delegate to setters iff called with arguments 
+#
+class AbstractWidget
+  class_trait 'color' => 'pinky-green'
+  class_trait 'size' => 42
+  class_trait 'shape' => 'square'
+
+  # we define instance traits which get their default from the class
+  %w( color size shape ).each{|t| trait(t){self.class.send t}}
+
+  def inspect
+    "color <#{ color }> size <#{ size }> shape <#{ shape }>"
+  end
+end
+
+class BlueWidget < AbstractWidget
+  color 'blue'
+  size 420
+end
+
+p BlueWidget::new

data/sample/k.rb

@@ -0,0 +1,36 @@
+require 'traits'
+#
+# the rememberance of traits can make generic intializers pretty slick 
+#
+class C 
+  #
+  # define class traits with defaults
+  #
+  class_traits(
+    'a' => 40,
+    'b' => 1,
+    'c' => 0
+  ) 
+
+  #
+  # define instance traits whose defaults come from readable class ones
+  #
+  class_rtraits.each{|ct| instance_trait ct => send(ct)}
+
+  #
+  # any option we respond_to? clobbers defaults
+  #
+  def initialize opts = {}
+    opts.each{|k,v| send(k,v) if respond_to? k}
+  end
+
+  #
+  # show anything we can read
+  #
+  def inspect
+    self.class.rtraits.inject(0){|n,t| n += send(t)}
+  end
+end
+
+c = C::new 'c' => 1
+p c

data/sample/l.rb

@@ -0,0 +1,15 @@
+require 'traits'
+#
+# even defining single methods on object behaves
+#
+a = [] 
+
+class << a
+  trait 'singleton_class' => class << self;self;end
+
+  class << self 
+    class_trait 'x' => 42
+  end
+end
+
+p a.singleton_class.x

data/sample/m.rb

@@ -0,0 +1,24 @@
+require 'traits'
+#
+# pre and post hooks can be passed a proc or the name of a method, the arity is
+# detected and the proc/method sent either the value, or the name/value pair
+#
+
+class C
+  HOOK_A = lambda{|value| puts "HOOK_A : #{ value }"}
+  HOOK_B = lambda{|name, value| puts "HOOK_B : #{ name } = #{ value }"}
+
+  def hook_a value
+    puts "hook_a : #{ value }"
+  end
+  def hook_b name, value
+    puts "hook_b : #{ name } = #{ value }"
+  end
+
+  trait 'x', 'pre' => HOOK_A, 'post' => 'hook_b'
+  trait 'y', 'pre' => HOOK_B, 'post' => 'hook_a'
+end
+
+c = C::new
+c.x = 42
+c.y = 'forty-two'

data/sample/n.rb

@@ -0,0 +1,37 @@
+require 'traits'
+#
+# two kinds of in-place modifications are supported : casting and munging. 
+# casting is a hook that requires either a proc or the name of a method that
+# will be used to convert the objects type.  munging is similar execpt the
+# method is called on the object itself.  like all hooks, lists may be provided
+# instead of a single argument
+#
+# you'll notice that the hooks and methods defined here are not strictly needed,
+# but are for illustration purposes only.  note that all hooks operate in the
+# context of self - they have access to instance vars, etc., like instance_eval
+#
+
+class C
+  INT = lambda{|i| int i}
+  def int i
+    Integer i
+  end
+  trait 'a', 'cast' => 'int'
+  trait 'b', 'cast' => INT 
+  trait 'c', 'munge' => 'to_i' 
+  trait 'd', 'cast' => 'Integer' 
+  trait 'e', 'munge' => %w( to_i abs )
+end
+
+c = C::new
+
+c.a = '42'
+p c.a
+c.b = '42'
+p c.b
+c.c = '42'
+p c.c
+c.d = '42'
+p c.d
+c.e = '-42'
+p c.e

data/sample/p.rb

@@ -0,0 +1,23 @@
+require 'traits'
+#
+# the TraitInit module provide a simple method for initializing an object's
+# traits from an options hash
+#
+
+class C
+  include TraitInit
+
+  LIST_OF_INTS = lambda{|a| Array === a and a.map{|i| Integer === i}.all?}
+  LIST_OF_STRINGS = lambda{|a| Array === a and a.map{|s| String === s}.all?}
+
+  trait :li, :validate => LIST_OF_INTS
+  trait :ls, :validate => LIST_OF_STRINGS
+
+  def initialize opts = {}
+    trait_init opts
+  end
+end
+
+c = C::new "li" => [4, 2], "ls" => %w[4 2]
+p c.li.join
+p c.ls.join