cheri 0.0.5 → 0.0.6

data/lib/cheri/builder/awt/main.rb

@@ -71,7 +71,7 @@ end #self
   #   awt([*args] [, &block]) -> AWTProxy if no block given, else result of block
   #   
   def awt(*r,&k)
-    if (ctx = __cheri_ctx)
+    if ctx = __cheri_ctx
       if k
         AWTFrame.new(ctx,*r,&k).run
       else

data/lib/cheri/builder/base.rb

@@ -25,7 +25,7 @@
 module Cheri
 module Builder
 
-# Frame contains default implementations of the methods required by objects that
+# Frame provides default implementations of the methods required by objects that
 # will be pushed onto the Cheri::Builder::Context stack.  Note that concrete
 # builders will need to override some of these methods, such as #mod, #parent? 
 # and #child?.
@@ -209,325 +209,5 @@ private
   end
 end #BaseBuilder
 
-# Appendable types define to_s, to_str and to_io methods that take an optional
-# parameter, to which output is appended.  This is essentially a marker interface;
-# the supplied implementations do nothing useful.
-module Appendable
-  # Append value (whatever that might be) to the supplied String, or create and
-  # return a new String if none is supplied. If #esc is overridden, value will
-  # be escaped first. Delegates to #to_io unless String === str.  Note that this
-  # implementation appends an empty string; override to do something useful.
-  def to_s(str='')
-    return to_io(str) unless String === str
-    esc('',str)
-  end
-  
-  # Calls #to_s(str).  Provided so that Appendable objects may be coerced to
-  # Strings automatically, as in <tt>str << my_appendable_thingy</tt>. Implemented
-  # this way rather than through alias_method to counter the possibility that
-  # overriders of #to_s will forget to re-alias to_str.
-  def to_str(str='')
-    to_s(str)  
-  end
-
-  # Append value (whatever that might be) to the supplied output stream.  If
-  # #esc is overridden, value will be escaped first. Note that this
-  # implementation appends an empty string; override to do something useful.
-  def to_io(ios)
-    ios << esc('')
-  end
-  
-  # Override to escape values (default implementation appends or returns
-  # the input value unaltered).
-  def esc(inp,out=nil)
-    out ? out << inp : inp
-  end
-
-end
-
-# Methods to support content (primarily intended for use with XML/HTML markup).
-# See also EmptyContent, ContentArgs.
-module Content
-  include Appendable
-  
-  # Adds +value+ to the content array (@cont) for this object if #content?(+value+)
-  # returns +true+.
-  def add(value)
-    (@cont ||= []) << value if content?(value)
-    self
-  end
-  alias_method :<<, :add  
-  
-  # Returns the content array (@cont) if present, otherwise +nil+.
-  def content
-    @cont  
-  end
-  
-  # Iterates over the content array (@cont) for this object. Equivalent to
-  # calling #content#each.
-  def each #:yields: content_value
-    @cont.each do |v|
-      yield v
-    end if @cont && block_given?
-  end
-
-  # Returns truth value if +value+ is valid content for this builder/object,
-  # +false+/+nil+ otherwise.  Called by #add before adding content; +value+ will
-  # not be added unless content? is true.
-  # 
-  # This implementation always returns +true+. Override to validate each content
-  # element before it is added.  You may wish to raise an exception or issue a 
-  # warning in the case of invalid content.
-  def content?(value)
-    true
-  end
-  
-  # Appends concatenated and escaped content (@cont) to +str+, if supplied, using
-  # the +<<+ operator.  Assumes String === +str+. Use #cont_io to append to IO or Array.
-  def cont_s(str='')
-    @cont.each do |v|
-      case v
-        when String     : esc(v,str)
-        when Appendable : v.to_s(str)
-        else esc(v.to_s,str)
-      end
-    end if @cont
-    str
-  end
-  
-  # Appends concatenated and escaped content (@cont) to +ios+, if supplied, using
-  # the +<<+ operator. Use for appending to IO or Array. Use #cont_s to append more
-  # efficiently to strings.
-  def cont_io(ios)
-    @cont.each do |v|
-      case v
-        when String     : ios << esc(v)
-        when Appendable : v.to_io(ios)
-        else ios << esc(v.to_s)
-      end
-    end if @cont
-    ios
-  end
-    
-  # Override to escape values by appending the escaped +inp+ value to output
-  # string +out+ (using << or concat). If +out+ is nil, just return the escaped
-  # string. The default implementation appends or returns the input value unaltered.
-  def esc(inp,out=nil)
-    out ? out << inp : inp
-  end
-
-end
-
-# Methods to support attributes (primarily intended for use with XML/HTML markup).
-# Note: include before ContentArgs if both are being included.
-module Attributes
-  include Appendable
-  #:stopdoc:
-  S = ' '.freeze
-  Q = '"'.freeze
-  E = '='.freeze
-  #:startdoc:
-  def initialize(*r,&k)
-    super
-    if @args && Hash === @args.last
-      @args.pop.each_pair do |n,v| add_attr(n,v); end
-    end
-  end
-
-  # Returns the attibutes hash (@attrs), if any.
-  def attrs
-    @attrs  
-  end
-  
-  # Add an attribute. Called by #initialize to add/validate attributes passed as
-  # arguments.
-  def add_attr(name,value)
-    (@attrs ||= {})[name] = value if attr?(name,value)
-  end
-
-  # Override to validate each attribute before it is added. The default
-  # implementation accepts any name/value.
-  def attr?(name,value)
-    true
-  end
-
-  # Writes attributes to a new string, or appends to an existing string
-  # (using <<) if supplied.
-  def attr_s(str='')
-    @attrs.each_pair do |k,v|
-      str << 32 << k.to_s << ?= << 34 << v.to_s << 34
-    end if @attrs
-    str
-  end
-  
-  # Writes attributes to the supplied IO stream (or Array, etc.) using <<.
-  def attr_io(ios)
-    @attrs.each_pair do |k,v|
-      ios << S << k << E << Q << v << Q
-    end if @attrs
-    ios
-  end
-end
-
-# Calls +add+ to add each argument passed to new/initialize. Use with Content
-# module if content values will be passed as arguments.  Note: include after
-# Attributes if both are being used.
-module ContentArgs
-  def initialize(*r,&k)
-    super
-    @args.each do |a| add a; end
-  end
-end #ContentArgs
-
-
-# Methods to support empty content models (primarily intended for use with XML/HTML markup).
-# See also Content, ContentArgs.
-module EmptyContent
-  include Appendable
-  CE = ' />'.freeze #:nodoc:
-
-  # Returns +false+
-  def content?(value)
-    false  
-  end
-  
-  def empty_s(str='')
-    str << CE
-  end
-
-  def empty_io(ios)
-    ios << CE
-  end
-
-end #EmptyContent
-
-module MarkupWriter
-  #:stopdoc:
-  C = '</'.freeze
-  E = '>'.freeze
-  EC = '></'.freeze
-  O = '<'.freeze
-  #:startdoc:
-
-  # Append this markup to +str+ (or an empty string if +str+ is not supplied),
-  # and return the result.  Redirects to #to_io if +str+ is not a String.  Both
-  # methods use the +<<+ operator to append their output; this method (like the other
-  # ..._s methods) is faster because Fixnum values can be appended directly, without
-  # being converted to (or passed as) strings. This takes on particular significance
-  # when output is being escaped, and values passed one character at a time.
-  def to_s(str='')
-    return to_io(str) unless String === str
-    open_s(str)
-    attr_s(str) if @attrs
-    if @cont
-      str << ?>
-      cont_s(str)
-      close_s(str)
-    else
-      empty_s(str)
-    end
-    str
-  end
-  
-  # Append this markup to +ios+
-  def to_io(ios)
-    open_io(ios)  
-    attr_io(ios) if @attrs
-    if @cont
-      ios << E
-      cont_io(ios)
-      close_io(ios)
-    else
-      empty_io(ios)
-    end
-    ios
-  end
-
-  # Append open tag (<tagname) to +str+ using +<<+.
-  def open_s(str)
-    str << ?< << (@tag ||= @sym.to_s)
-  end
-  
-  # Append open tag (<tagname) to +ios+ using +<<+.
-  def open_io(ios)
-    ios << O << (@tag ||= @sym.to_s)
-  end
-  
-  # Append close tag (</tagname>) to +str+ using +<<+.
-  def close_s(str)
-    str << C << @tag << ?>
-  end
-  
-  # Append close tag (</tagname>) to +ios+ using +<<+.  (Use slightly faster
-  # #close_s for strings.)
-  def close_io(ios)
-    ios << C << @tag << E  
-  end
-  
-  # Append empty close tag (...></tagname>) to +str+. Note that HTML/XML elements
-  # with empty content models should close with <tt>' />'</tt> instead (see EmptyContent).
-  def empty_s(str)
-    str << EC << @tag << ?>
-  end
-  
-  # Append empty close tag (...></tagname>) to +ios+. Note that HTML/XML elements
-  # with empty content models should close with <tt>' />'</tt> instead (see EmptyContent).
-  def empty_io(ios)
-    ios << EC << @tag << E
-  end
-  
-end #MarkupWriter
-
-module Markup
-  include Content
-  include Attributes
-  include ContentArgs
-  include MarkupWriter
-end #Markup
-
-module EmptyMarkup
-  # We include Content and ContentArgs so that warnings/exceptions may be
-  # issued (by overriding #add or #content?) if the user attempts to add to this element.
-  # Otherwise, unconnectable elements would simply be ignored.
-  include Markup
-#  include Content
-#  include Attributes
-#  include ContentArgs
-#  include MarkupWriter
-  include EmptyContent
-end #EmptyMarkup
-
-module MarkupBuilder
-  include Builder
-  include Markup
-  
-  def object
-    self  
-  end
-
-  def run
-    value = @ctx.call(self,&@blk) if @blk
-    add(value) if String === value
-    self
-  end
-end #MarkupBuilder
-
-module EmptyMarkupBuilder
-  include Builder
-  include EmptyMarkup
-  
-  def object
-    self  
-  end
-  
-  def run
-    value = @ctx.call(self,&@blk) if @blk
-    # of course we want this to then fail in #add / #content?  e.g., see Cheri::Html::EmptyElem
-    add(value) if String === value
-    self
-  end
-
-end #EmptyMarkupBuilder
-
 end #Builder
 end #Cheri

data/lib/cheri/builder/config.rb

@@ -62,13 +62,11 @@ class Config
     validate(mod) unless mod == Cheri::Builder
     extendee = mod.respond_to?(:extends) ? mod.extends : nil
     raise BuilderException,"extended builder module not included: #{extendee}" if extendee && !@m.include?(extendee)
-    #puts "config add mod #{mod}"
     @m << mod
     @f[mod] = mod.factory if mod.respond_to?(:factory) && mod.factory
     @c[mod] = mod.connecter if mod.respond_to?(:connecter) && mod.connecter
     (@n ||= {})[mod] = mod.consumer if mod.respond_to?(:consumer) && mod.consumer
     (@r ||= {})[mod] = mod.resolver if mod.respond_to?(:resolver) && mod.resolver
-    #puts "@n = #{@n}"
     extend_mod(extendee,mod) if extendee
     self
   end
@@ -145,6 +143,12 @@ class Config
   def copy
     self.class.allocate.copy_from(@m,@f,@c,@n,@r)
   end
+
+  # Overrides the default Object#inspect to prevent mind-boggling circular displays in IRB.
+  def inspect
+    "#<#{self.class}:instance>"  
+  end
+
 protected
   def copy_from(m,f,c,n,r)
     @m = m.dup

data/lib/cheri/builder/context.rb

@@ -25,15 +25,13 @@
 module Cheri
 module Builder
 
-
-  # !!! TODO: class-level properties
-
 class InstanceContext
   # TODO: defined?Java pulls it in (same as require 'java' or include Java)
   # not sure if anyone would object...
   if (defined?Java) && (defined?JRUBY_VERSION) # JRuby 0.9.9 or later
     Col = java.util.Collections
-    Map = java.util.WeakHashMap
+    Map = java.util.HashMap
+    WMap = java.util.WeakHashMap
   end
 
   # call-seq:
@@ -42,10 +40,15 @@ class InstanceContext
   def initialize(client,cfg)
     @c = client
     @g = cfg
-    
+    # TODO: properties, aliases should probably be threadsafe hashes/maps,
+    # though contention would be extremely unlikely given expected usage (any
+    # puts likely to be made on the instantiating thread, immediately
+    # upon instantiation).
+    @p = {} # properties
+    @l = {} # aliases
     # TODO: find a better way to do this    
     if self.class.const_defined?("Map")
-      @h = Col.synchronized_map Map.new
+      @h = Col.synchronized_map WMap.new
       @t = true # use Thread as key
     else
       # TODO: should use weak hash here
@@ -79,14 +82,22 @@ class InstanceContext
     end
   end
   
+  def props
+    @p  
+  end
+  
   def [](k)
-    @g[k]
+    @p[k]
   end
   
   def []=(k,v)
-    @g[k] = v
+    @p[k] = v
   end
-
+  
+  def aliases
+    @l
+  end
+  
   # call-seq:
   #   current -> context object for the current instance/thread
   #   
@@ -94,6 +105,11 @@ class InstanceContext
     key = @t ? Thread.current : Thread.current.__id__
     @h[key] ||= Context.new(self,@c)
   end
+  
+  # Overrides the default Object#inspect to prevent mind-boggling circular displays in IRB.
+  def inspect
+    "#<#{self.class}:instance>"  
+  end
 
 end #InstanceContext
 
@@ -112,6 +128,7 @@ class Context
   #   @g - reference to the class's Config instance (all included Cheri builder modules)
   #   @p - configuration properties hash, used for various purposes
   #   @i - reference to the InstanceContext that created this Context
+  #   @l - reference to aliases from InstanceConfig
   #   @m - the ConnectionMinder for this context, tracks pending (prepared) connections
   #   @n - reference to the connecters in the class's Config instance
   #   @r - array of ConstantResolver instances, lazily initialized
@@ -128,6 +145,7 @@ class Context
     if (u = ictx.auto)
       @u = u.dup
     end
+    @l = ictx.aliases
     @c = client
     @m = ConnectionMinder.new
     @s = [] # stack
@@ -190,6 +208,8 @@ class Context
   # method_missing (the usual caller) empty-handed. 
   def send(sym,*r,&k)
     raise Cheri.type_error(sym,Symbol) unless sym.instance_of?(Symbol)
+    # substitute sym for alias, if any
+    sym = @l[sym] if @l[sym]
     # check args against pending connections (see note at ConnectionMinder)
     @m.ck(sym,*r)
     # first try for a builder matching sym
@@ -213,16 +233,45 @@ class Context
   # Version of +send+ intended for use by proxy objects. The supplied module's factory
   # _must_ be able to resolve the symbol; otherwise, a NoMethodError will be raised.
   def msend(m,sym,*r,&k)
-    #puts "fsend sym: #{sym}"
     # ok for stack to be empty for this call, so no check
     raise Cheri.type_error(sym,Symbol) unless sym.instance_of?(Symbol)
     raise ArgumentError,"not a valid builder module: #{m}" unless (f = @f[m])
+    # substitute sym for alias, if any
+    sym = @l[sym] if @l[sym]
+    # check args against pending connections (see note at ConnectionMinder)
+    @m.ck(sym,*r)
+    # the factory _must_ be able to return a matching builder
+    unless (b = f.builder(self,sym,*r,&k))
+      raise NoMethodError,"undefined method '#{sym}' for #{m}"
+    end
+    # run it
+    res = b.run
+    # connect it
+    ctc(b)
+    res
+  end
+
+  # call-seq:
+  #   ctx.nsend(builder_module, namespace_sym, sym, *args, &block) -> result
+  # 
+  # Version of +send+ intended for use by namespace objects. The supplied module's factory
+  # _must_ be able to resolve the symbol; otherwise, a NoMethodError will be raised. The
+  # resulting builder _must_ supply a +ns=+ method; otherwise a TypeError will be raised.
+  def nsend(m,ns,sym,*r,&k)
+    # ok for stack to be empty for this call, so no check
+    raise Cheri.type_error(ns,Symbol) unless Symbol === ns
+    raise Cheri.type_error(sym,Symbol) unless Symbol === sym
+    raise ArgumentError,"not a valid builder module: #{m}" unless (f = @f[m])
+    # substitute sym for alias, if any
+    sym = @l[sym] if @l[sym]
     # check args against pending connections (see note at ConnectionMinder)
     @m.ck(sym,*r)
     # the factory _must_ be able to return a matching builder
     unless (b = f.builder(self,sym,*r,&k))
       raise NoMethodError,"undefined method '#{sym}' for #{m}"
     end
+    raise Cheri.type_error(b,Markup) unless b.respond_to?(:ns=)
+    b.ns = ns
     # run it
     res = b.run
     # connect it
@@ -498,11 +547,18 @@ class Context
     end
     
     # now attempt connections for any 'any' objects on the stack
-    @a.reverse_each do |a|
-      if a.object && (n = @n[a.mod])
-        n.prepare(self,a,obj,sym,props)
+    if @a
+      @ax = true
+      begin
+      @a.reverse_each do |a|
+        if a.object && (n = @n[a.mod])
+          n.prepare(self,a,obj,sym,props)
+        end
+      end
+      ensure
+      @ax = nil
       end
-    end if @a
+    end
 
     nil
   end
@@ -530,7 +586,19 @@ class Context
   def []=(k,v)
     @p[k]=v  
   end
-    
+  
+  # call-seq:
+  #   ctx.aliases -> aliases hash
+  #   ctx.als -> aliases hash
+  # 
+  def als
+    @l  
+  end
+  # :stopdoc:
+  alias_method :aliases, :als
+  # :startdoc:
+
+
   # call-seq:
   #   prepared(connecter,builder,obj,sym,props=nil) -> true
   #   ppd(connecter,builder,obj,sym,props=nil) -> true
@@ -546,16 +614,13 @@ class Context
   # Note that if you are using TypeConnecter (highly recommended where appropriate), this all
   # takes place behind the scenes, so you don't need to call this method directly.
   def ppd(ctr,bldr,obj,sym,props=nil)
-    @m.ppd(ctr,bldr,obj,sym,props)
+    unless @ax
+      @m.ppd(ctr,bldr,obj,sym,props)
+    else
+      @m.ppda(ctr,bldr,obj,sym,props)
+    end
   end
   alias_method :prepared, :ppd #:nodoc:
-  
-  # TODO: this is internal now, don't need a method ?
-#  def ck(*r)
-#    @m.check(*r)
-#  end
-#  alias_method :check, :ck
-#
 
   # Overrides the default Object#inspect to prevent mind-boggling circular displays in IRB.
   def inspect
@@ -567,9 +632,10 @@ class Context
   # being called will do whatever is needed (except for cherify,
   # which _wants_ its arg connected). Note that we can only catch
   # those passed to cheri-invoked ctors/methods.
-  class ConnectionMinder #:nodoc: all
+  class ConnectionMinder # :nodoc: all
     def initialize
       @c = {} # pending connections. indexed by builder.__id__
+      #@a = {} # pending 'any' connections. indexed by builder.__id__
       @o = {} # pending builder(object)s. indexed by object.__id__
     end
 
@@ -577,7 +643,6 @@ class Context
     # an array to hold pending connections for that builder
     def pu(b)
       @c[b.__id__] = []
-      #@a
     end
     alias_method :pushed, :pu #:nodoc:
     
@@ -585,6 +650,11 @@ class Context
     # pending (prepared) connections, and remove each builder/object
     # associated with a connection from the pending objects hash.
     def po(b)
+      if @a && (ac = @a.delete b.__id__)
+        ac.each do |c|
+          c.connect rescue nil
+        end
+      end
       if (cs = @c.delete b.__id__)
         begin
           cs.each do |c| c.connect; end
@@ -604,6 +674,13 @@ class Context
     end
     alias_method :prepared, :ppd #:nodoc:
 
+    # store a prepared 'any' connection.
+    def ppda(ctr,bldr,obj,sym,props=nil)
+      ((@a ||= {})[bldr.__id__] ||= []) << Con.new(ctr,bldr.object,obj,sym,props)
+      true
+    end
+    alias_method :prepared_any, :ppda # :nodoc:
+
     # check args passed to ctors/methods against the pending objects hash,
     # and remove any matches from the pending connections/objects hashes.
     def ck(y,*r)
@@ -637,7 +714,7 @@ class Context
     end
     alias_method :check, :ck #:nodoc:
 
-    class Con #:nodoc: all
+    class Con # :nodoc: all
       def initialize(ctr,par,obj,sym,props)
         @c = ctr
         @p = par