cheri 0.0.5 → 0.0.6

data/lib/cheri/builder/generator.rb

@@ -49,11 +49,13 @@ class Generator
   end #self
   end #Template
   
-  class TypeBuilder < Cheri::Builder::AbstractBuilder
-    def initialize(mod,clazz,*r,&k)
+  class TypeBuilder
+    include Cheri::Builder::Builder
+    def initialize(mod,type,*r,&k)
       super(*r,&k)
       @mod = mod
-      @clazz = clazz
+      @type = type
+      @clazz = type.clazz
     end
     # returns the module to which this builder belongs
     def mod
@@ -64,6 +66,15 @@ class Generator
       @ctx.call(self,&@blk) if @blk
       @obj
     end
+    def parent?
+      @type.parent?    
+    end
+    def child?
+      @type.child?
+    end
+    def any?
+      @type.any?
+    end
   end #TypeBuilder
 
   class CherifyBuilder  < Cheri::Builder::AbstractBuilder
@@ -90,14 +101,14 @@ class Generator
 
   class TypeFactory
     def initialize(mod,types)
-      raise Cheri.type_error(types,Hash) unless Hash === types
+      raise Cheri.type_error(types,BuildTypes) unless BuildTypes === types
       @mod = mod
       @types = types
       @inv = types.invert
     end
     def builder(ctx,sym,*r,&k)
-      if (clazz = @types[sym])
-        TypeBuilder.new(@mod,clazz,ctx,sym,*r,&k)
+      if (type = @types[sym])
+        TypeBuilder.new(@mod,type,ctx,sym,*r,&k)
       elsif @inv[r.first.class]
         if sym == :cherify
           CherifyBuilder.new(@mod,ctx,sym,*r,&k)
@@ -112,16 +123,17 @@ class Generator
     end
   end #TypeFactory
 
+  # Factory for self-building types (e.g., Cheri markup types)
   class AutoFactory
     def initialize(mod,types)
-      raise Cheri.type_error(types,Hash) unless Hash === types
+      raise Cheri.type_error(types,BuildTypes) unless BuildTypes === types
       @mod = mod
       @types = types
       @inv = types.invert
     end
     def builder(ctx,sym,*r,&k)
-      if (clazz = @types[sym])
-        bld = clazz.new(ctx,sym,*r,&k)
+      if (type = @types[sym])
+        bld = type.clazz.new(ctx,sym,*r,&k)
       elsif @inv[r.first.class]
         if sym == :cherify
           CherifyBuilder.new(@mod,ctx,sym,*r,&k)
@@ -152,7 +164,7 @@ class Generator
       create_mod(eb)
     else
       # _really_ simple builder
-      @types = {}
+      @types = BuildTypes.new
       @ctr = TypeConnecter.new
       if Hash === @args.last
         @args.pop.each_pair do |clazz,adder|
@@ -173,7 +185,7 @@ class Generator
     sym ||= make_sym(clazz)
     adder = adder.to_sym
     warn "warning: redefining type #{sym} => #{clazz}" if @types[sym]
-    @types[sym] = clazz
+    @types[sym] = BuildType.new(clazz,sym)
     @ctr.add_type(clazz).connect(Object,adder)
   end
   private :add_type
@@ -214,8 +226,8 @@ class Generator
     unless unmapped.empty?
       iv = mapped.invert
       unmapped.each do |unm|
-        unless iv[unm]
-          sym = make_sym(unm)
+        unless iv[unm.clazz]
+          sym = make_sym(unm.clazz)
           if (dupl = mapped[sym])
             warn "warning: derived symbol #{sym} (#{unm}) conflicts with symbol for #{dupl} -- ignoring"
           else
@@ -228,9 +240,9 @@ class Generator
     # separate the Java classes (if any)
     jmapped = nil
     if !mapped.empty? && defined?Cheri::Java::Builder
-      jmapped = {}
-      mapped.each_pair do |sym,clazz|
-        jmapped[sym] = clazz if clazz.respond_to?(:java_class)
+      jmapped = BuildTypes.new
+      mapped.each_pair do |sym,type|
+        jmapped[sym] = type if type.clazz.respond_to?(:java_class)
       end
       if jmapped.empty?
         jmapped = nil        
@@ -245,11 +257,9 @@ class Generator
     # doesn't (currently) apply to Java classes (and likely never will)
     amapped = nil
     unless mapped.empty?
-      amapped = {}
-      mapped.each_pair do |sym,clazz|
-        if clazz < Cheri::Builder::Frame
-          amapped[sym] = clazz
-        end
+      amapped = BuildTypes.new
+      mapped.each_pair do |sym,type|
+        amapped[sym] = type if type.clazz < Cheri::Builder::Frame
       end
       if amapped.empty?
         amapped = nil
@@ -332,13 +342,9 @@ class Generator
   private :create_mod
 
   class EvalBuilder
-#    keep = /^(__|=|<|>|class|to_s|eql\?|equal\?|inspect|require|warn|instance_|respond_to\?)/
-#    instance_methods.each do |m|
-#      undef_method m unless m =~ keep  
-#    end
 
     def initialize(*r,&k)
-      @__mapped = {}
+      @__mapped = BuildTypes.new
       @__unmapped = []
       instance_eval(&k)  
     end
@@ -373,27 +379,27 @@ class Generator
       @__ext = bld
     end
 
-    def build(type,sym=nil)
+    def build(type,sym=nil,&k)
       raise Cheri.type_error(type,Class) unless Class === type
       if sym
         if Symbol === sym
-          add_mapped(type,sym)
+          add_mapped(type,sym,&k)
         elsif Array === sym
           sym.each do |s|
             raise Cheri.type_error(s,Symbol) unless Symbol === s
-            add_mapped(type,s)        
+            add_mapped(type,s,&k)        
           end
         else
           raise Cheri.type_error(sym,Symbol,Array)
         end
       else
-        @__unmapped << type unless @__unmapped.include?(type) 
+        @__unmapped << BuildType.new(type,nil,&k) unless @__unmapped.include?(type) 
       end
     end
   
-    def add_mapped(type,sym)
+    def add_mapped(type,sym,&k)
       warn "warning: redefining :#{sym} from #{@__mapped[sym]} to #{type}" if @__mapped[sym]
-      @__mapped[sym] = type
+      @__mapped[sym] = BuildType.new(type,sym,&k)
     end
     private :add_mapped
  

data/lib/cheri/builder/html/element.rb

@@ -34,7 +34,7 @@ end
 # Included by all Cheri::Html builders
 module HtmlBuilder
   def esc(inp,out=nil)
-    if @ctx[:html_esc] && (cs = Charsets.charset(inp))
+    if @opt[:esc] && (cs = Charsets.charset(inp))
       cs.xlat(inp,(out ||= ''))
       out
     elsif out
@@ -43,16 +43,32 @@ module HtmlBuilder
       inp
     end
   end  
-end #XmlBuilder
+end #HtmlBuilder
 
 class Elem
   include Cheri::Builder::MarkupBuilder
   include HtmlBuilder
   include HtmlElement
 
+  def initialize(ctx,*r,&k)
+    opt = @opt = ctx[:html_opts] || {}
+    @fmt = true if opt[:format]
+    @amap = opt[:attr] if opt[:attr]
+    super
+  end
+  
   def mod
     Cheri::Html  
   end
+  
+  def margin
+    @mrg || @opt[:margin] || @ctx[:margin] || 0
+  end
+
+  def indent
+    @idt || @opt[:indent] || @ctx[:indent] || 0
+  end
+  
 end
 
 class EmptyElem
@@ -60,39 +76,54 @@ class EmptyElem
   include HtmlBuilder
   include HtmlElement
 
+  def initialize(ctx,*r,&k)
+    opt = @opt = ctx[:html_opts] || {}
+    @fmt = true if opt[:format]
+    @amap = opt[:attr] if opt[:attr]
+    super
+  end
+  
   def mod
     Cheri::Html  
   end
 
-  def content?(value)
+  def add?(value)
     raise HtmlException,"content not allowed for empty element #{@sym}: #{value}"  
   end
+
+  def margin
+    @mrg || @opt[:margin] || @ctx[:margin] || 0
+  end
+
+  def indent
+    @idt || @opt[:indent] || @ctx[:indent] || 0
+  end
+  
 end
 
 
 class TextElem
-  include Cheri::Builder::Builder
-  include Cheri::Builder::Content
-  include Cheri::Builder::ContentArgs
+  include Cheri::Builder::MarkupLikeBuilder
   include HtmlBuilder
   
-  def mod
-    Cheri::Html  
+  def initialize(ctx,*r,&k)
+    @opt = ctx[:html_opts] || {}
+    super
   end
-
-  def object
-    self
+  
+  def set?(n,v)
+    raise HtmlException,"attribute not allowed for text element #{@sym}: #{n}=#{v}"  
   end
+  private :set?
   
-  def run
-    value = @ctx.call(self,&@blk) if @blk
-    add(value) if value && !(Appendable === value)
-    self
+  def mod
+    Cheri::Html  
   end
 
   # Appends content to +str+, or to an empty string if +str+ is omitted.
   # Returns the result.
   def to_s(str='')
+    return to_io(str) unless String === str
     @cont.each do |c|
       if String === c
         esc(c,str)
@@ -132,10 +163,69 @@ class EscElem < TextElem
 
 end
 
+class CommentElem
+  include Cheri::Builder::CommentBuilder
+  include HtmlBuilder
+  include HtmlElement
+
+  def initialize(ctx,*r,&k)
+    opt = @opt = ctx[:html_opts] || {}
+    @fmt = true if opt[:format]
+    super
+  end
+
+  def set?(n,v)
+    raise HtmlException,"attribute not allowed for comment #{@sym}: #{n}=#{v}"  
+  end
+  private :set?
+  
+  def mod
+    Cheri::Html  
+  end
+
+  def margin
+    @mrg || @opt[:margin] || @ctx[:margin] || 0
+  end
+
+  def indent
+    @idt || @opt[:indent] || @ctx[:indent] || 0
+  end
+
+end #CommentElem
+
 # TODO: special handling for these:
 
 class HtmlElem < Elem
-end
+  LOOSE1 = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n"
+  LOOSE2 = "        \"http://www.w3.org/TR/html4/loose.dtd\">\n"
+  STRICT1 = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n"
+  STRICT2 = "        \"http://www.w3.org/TR/html4/strict.dtd\">\n"
+  Markup = Cheri::Builder::Markup
+
+  def to_s(str='')
+    return to_io(str) unless String === str
+    if @opt[:doctype]
+      strict = @opt[:strict]
+      str << Markup.sp(margin) if @fmt
+      str << (strict ? STRICT1 : LOOSE1)
+      str << Markup.sp(margin) if @fmt
+      str << (strict ? STRICT2 : LOOSE2)
+    end
+    super(str)
+  end
+
+  def to_io(ios)
+    if @opt[:doctype]
+      strict = @opt[:strict]
+      ios << Markup.sp(margin) if @fmt
+      ios << (strict ? STRICT1 : LOOSE1)
+      ios << Markup.sp(margin) if @fmt
+      ios << (strict ? STRICT2 : LOOSE2)
+    end
+    super(ios)
+  end
+
+end #HtmlElem
 
 class BodyElem < Elem
 end

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

@@ -51,18 +51,31 @@ end #self
   #   html([*args] [, &block]) -> HtmlProxy if no block given, else result of block
   #   
   def html(*r,&k)
-    if (ctx = __cheri_ctx)
+    if ctx = __cheri_ctx
+      unless copts = ctx[:html_opts]
+        iopts = ctx.ictx[:html_opts] ||= HtmlOptions.new
+        copts = ctx[:html_opts] = HtmlOptions.new(iopts)
+      end
       if k
-      
-        # TODO: search stack for Html?
-        # new HtmlElement if stack empty, maybe other cases?
         if ctx.tos(HtmlElement)
           HtmlFrame.new(ctx,*r,&k).run
         else
-          ctx.msend(Cheri::Html,:html,*r,&k)
+          if r.empty?
+            ctx.msend(Cheri::Html,:html,&k)
+          else
+            copts.ingest_args(*r)
+            if args = copts.delete(:args)
+              ctx.msend(Cheri::Html,:html,args,&k)
+            else
+              ctx.msend(Cheri::Html,:html,&k)
+            end
+          end
         end
-      
       else
+        unless r.empty?
+          copts.ingest_args(*r)
+          copts.delete(:args)
+        end
         ctx[:html_proxy] ||= HtmlProxy.new(ctx,*r)
       end
     end
@@ -72,11 +85,91 @@ end #self
 
 module HtmlFactory
   def self.builder(ctx,sym,*r,&k)
+    opts = ctx[:html_opts] || {}
+    if ((als = opts[:alias]) && (asym = als[sym])) || (asym = Aliases[sym])
+      sym = asym
+    end
     clazz = Types[sym]
     clazz ? clazz.new(ctx,sym,*r,&k) : nil
   end
 end #HtmlFactory
 
+class HtmlOptions < Cheri::Builder::BaseOptions
+  def validate(key,value)
+    raise Cheri.type_error(key,Symbol) unless Symbol === key
+    case key
+      when :esc : validate_boolean_nil(value) || nil
+      when :doctype : validate_boolean_nil(value) || nil
+      when :strict : validate_boolean_nil(value) || nil
+      when :validate : validate_boolean_nil(value) || nil
+      when :warn : validate_boolean_nil(value) || nil
+      when :raise : validate_boolean_nil(value) || nil
+      when :format : validate_boolean_nil(value) || nil
+      when :indent
+        unless Fixnum === value
+          if true == value
+            value = 2
+          elsif false == value || nil == value
+            value = nil
+          else
+            raise Cheri.type_error(value,Fixnum,TrueClass,FalseClass,NilClass)
+          end
+        end
+        store(:format,true) if value
+        value
+      when :margin
+        unless Fixnum === value
+          if false == value || nil == value
+            value = nil
+          else
+            raise Cheri.type_error(value,Fixnum,FalseClass,NilClass)
+          end
+        end
+        store(:format,true) if value
+        value
+      when :alias
+        if Array === value
+          raise ArgumentError,"odd number of values for :alias" if ((len = value.length) & 1) == 1
+          als = self[:alias] || {}
+          (len>>1).times do |i|
+            als[value[i*2].to_sym] = value[i*2+1].to_sym
+          end
+          als
+        elsif Hash === value
+          value.each_pair do |k,v|
+            validate_symbol(k)
+            validate_symbol(v)
+          end
+          value
+        else
+          raise Cheri.type_error(value,Array,Hash)
+        end
+      when :attr
+        if Array === value
+          raise ArgumentError,"odd number of values for :attr" if ((len = value.length) & 1) == 1
+          als = self[:attr] || {}
+          (len>>1).times do |i|
+            als[value[i*2].to_sym] = value[i*2+1].to_sym
+          end
+          als
+        elsif Hash === value
+          value.each_pair do |k,v|
+            validate_symbol(k)
+            validate_symbol(v)
+          end
+          value
+        else
+          raise Cheri.type_error(value,Array,Hash)
+        end
+    else
+      # anything else gets passed through as args to html
+      args = self[:args] ||= {}
+      args[key] = value
+      nil
+    end
+  end
+end #HtmlOptions
+
 class HtmlProxy < Cheri::Builder::BaseProxy
 
   impl(Types.keys)
@@ -86,17 +179,14 @@ class HtmlProxy < Cheri::Builder::BaseProxy
   end
   private :mod
 
-  def [](opts)
-    if Symbol === opts
-      case opts
-        when :esc : @ctx[:html_esc] = true
-        else raise ArgumentError,"invalid simple html option: :#{opts}"
-      end
-    elsif Hash === opts
-      @ctx[:html_esc] = opts[:esc] != false if opts[:esc] != nil
-    else
-      raise Cheri.type_error(opts,Hash,Symbol)
-    end
+  def [](*args)
+    ictx = (ctx = @ctx).ictx
+    iopts = ictx[:html_opts] ||= HtmlOptions.new
+    iopts.ingest_args(*args)
+    iopts.delete(:args)
+    copts = ctx[:html_opts] ||= HtmlOptions.new
+    copts.ingest_args(*args)
+    copts.delete(:args)
     nil
   end
 end #HtmlProxy
@@ -104,12 +194,28 @@ end #HtmlProxy
 class HtmlFrame
   include Cheri::Builder::Frame
   def initialize(ctx,*r,&k)
-    super
+    super(ctx,&k)
     @obj = ctx[:html_proxy] ||= HtmlProxy.new(ctx,*r)  
-  end
+    @args = r unless r.empty?
+   end
   def mod
     Cheri::Html  
   end
+  def run
+    if blk = @blk
+      if args = @args
+        opts = (ctx = @ctx)[:html_opts]
+        temp = HtmlOptions.new(opts)
+        temp.ingest_args(*args)
+        ctx[:html_opts] = temp
+        result = ctx.call(self,&blk)
+        ctx[:html_opts] = opts
+        result
+      else
+        @ctx.call(self,&blk)
+      end
+    end
+  end
 end #HtmlFrame
 
 end #Html