xx 2.0.0 → 2.1.0

data/lib/binding_of_caller.rb

@@ -0,0 +1,83 @@
+unless(defined?(Continuation) and Continuation.respond_to?('create'))
+  # to satisfy rdoc
+  class Continuation #:nodoc:
+  end
+  def Continuation.create(*args, &block) # :nodoc:
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
+end
+
+class Binding; end # for RDoc
+# This method returns the binding of the method that called your
+# method. It will raise an Exception when you're not inside a method.
+#
+# It's used like this:
+#   def inc_counter(amount = 1)
+#     Binding.of_caller do |binding|
+#       # Create a lambda that will increase the variable 'counter'
+#       # in the caller of this method when called.
+#       inc = eval("lambda { |arg| counter += arg }", binding)
+#       # We can refer to amount from inside this block safely.
+#       inc.call(amount)
+#     end
+#     # No other statements can go here. Put them inside the block.
+#   end
+#   counter = 0
+#   2.times { inc_counter }
+#   counter # => 2
+#
+# Binding.of_caller must be the last statement in the method.
+# This means that you will have to put everything you want to
+# do after the call to Binding.of_caller into the block of it.
+# This should be no problem however, because Ruby has closures.
+# If you don't do this an Exception will be raised. Because of
+# the way that Binding.of_caller is implemented it has to be
+# done this way.
+def Binding.of_caller(&block)
+  old_critical = Thread.critical
+  Thread.critical = true
+  count = 0
+  cc, result, error, extra_data = Continuation.create(nil, nil)
+  error.call if error
+
+  tracer = lambda do |*args|
+    type, context, extra_data = args[0], args[4], args
+    if type == "return"
+      count += 1
+      # First this method and then calling one will return --
+      # the trace event of the second event gets the context
+      # of the method which called the method that called this
+      # method.
+      if count == 2
+        # It would be nice if we could restore the trace_func
+        # that was set before we swapped in our own one, but
+        # this is impossible without overloading set_trace_func
+        # in current Ruby.
+        set_trace_func(nil)
+        cc.call(eval("binding", context), nil, extra_data)
+      end
+    elsif type == "line" then
+      nil
+    elsif type == "c-return" and extra_data[3] == :set_trace_func then
+      nil
+    else
+      set_trace_func(nil)
+      error_msg = "Binding.of_caller used in non-method context or " +
+        "trailing statements of method using it aren't in the block."
+      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
+    end
+  end
+
+  unless result
+    set_trace_func(tracer)
+    return nil
+  else
+    Thread.critical = old_critical
+    case block.arity
+      when 1 then yield(result)
+      else yield(result, extra_data)        
+    end
+  end
+end

data/lib/xx-2.1.0.rb

@@ -0,0 +1,925 @@
+unless(defined?($__xx_rb__) or defined?(XX))
+
+require "rexml/document"
+
+module XX
+#--{{{
+  VERSION = "2.1.0"
+  def self.version() VERSION end
+
+  LIBDIR = File.dirname(File.expand_path(__FILE__)) << File::SEPARATOR
+  def self.libdir() LIBDIR end
+
+  require libdir + "binding_of_caller"
+
+  %w(
+    CRAZY_LIKE_A_HELL
+    PERMISSIVE
+    STRICT
+    ANY
+  ).each{|c| const_set c, c}
+
+  class Document
+#--{{{
+    attr "doc"
+    attr "stack"
+    attr "size"
+    attr_accessor "xmldecl"
+
+    def initialize *a, &b
+#--{{{
+      @doc = ::REXML::Document::new *a, &b
+      @stack = [@doc]
+      @xmldecl = nil
+      @size = 0
+#--}}}
+    end
+    def top
+#--{{{
+      @stack.last
+#--}}}
+    end
+    def push element
+#--{{{
+      @stack.push element
+#--}}}
+    end
+    def pop
+#--{{{
+      @stack.pop unless @stack.size == 1
+#--}}}
+    end
+    def tracking_additions
+#--{{{
+      n = @size
+      yield
+      return @size - n
+#--}}}
+    end
+    def to_str port = ""
+#--{{{
+      xmldecl ? ugly(port) : pretty(port)
+#--}}}
+    end
+    alias_method "to_s", "to_str"
+    def pretty port = ""
+#--{{{
+      @doc.write port, indent=0, transitive=false, ie_hack=true
+      port
+#--}}}
+    end
+    def ugly port = '' 
+#--{{{
+      @doc.write port, indent=-1, transitive=false, ie_hack=true
+      port
+#--}}}
+    end
+    alias_method "compact", "ugly"
+    def create element
+#--{{{
+      push element
+      begin
+        object = nil
+        additions =
+          tracking_additions do
+            object = yield element if block_given?
+          end
+        if object and additions.zero?
+          self << object
+        end
+      ensure
+        pop
+      end
+      self << element
+      element
+#--}}}
+    end
+    def << object
+#--{{{
+      t, x = top, object
+
+      if x
+        case t
+          when ::REXML::Document
+
+            begin
+              t <<
+                case x
+                  when ::REXML::Document
+                    x.root || ::REXML::Text::new(x.to_s)
+                  when ::REXML::Element
+                    x
+                  when ::REXML::CData
+                    x
+                  when ::REXML::Text
+                    x
+                  else # string
+                    ::REXML::Text::new(x.to_s)
+                end
+            rescue
+              if t.respond_to? "root"
+                t = t.root
+                retry
+              else
+                raise
+              end
+            end
+
+          when ::REXML::Element
+            t <<
+              case x
+                when ::REXML::Document
+                  x.root || ::REXML::Text::new(x.to_s)
+                when ::REXML::Element
+                  x
+                when ::REXML::CData
+                  #::REXML::Text::new(x.write(""))
+                  x
+                when ::REXML::Text
+                  x
+                else # string
+                  ::REXML::Text::new(x.to_s)
+              end
+
+          when ::REXML::Text
+            t <<
+              case x
+                when ::REXML::Document
+                  x.write ""
+                when ::REXML::Element
+                  x.write ""
+                when ::REXML::CData
+                  x.write ""
+                when ::REXML::Text
+                  x.write ""
+                else # string
+                  x.to_s
+              end
+
+          else # other - try anyhow 
+            t <<
+              case x
+                when ::REXML::Document
+                  x.write ""
+                when ::REXML::Element
+                  x.write ""
+                when ::REXML::CData
+                  x.write ""
+                when ::REXML::Text
+                  x.write ""
+                else # string
+                  x.to_s
+              end
+        end
+      end
+
+      @size += 1
+      self
+#--}}}
+    end
+#--}}}
+  end
+
+  module Markup
+#--{{{
+    class Error < ::StandardError; end
+
+    module InstanceMethods
+#--{{{
+      def _ tag_name, *a, &b
+#--{{{
+        hashes, nothashes = a.partition{|x| Hash === x}
+
+        doc = xx_doc
+        element = ::REXML::Element::new "#{ tag_name }"
+
+        hashes.each{|h| h.each{|k,v| element.add_attribute k.to_s, v}}
+        nothashes.each{|nh| element << ::REXML::Text::new(nh.to_s)}
+
+        doc.create element, &b
+#--}}}
+      end
+      alias_method "xx_tag" , "_"
+      alias_method "__"      , "_"
+      alias_method "g__"      , "_"
+      def method_missing m, *a, &b
+#--{{{
+        m = m.to_s
+
+        tag_name = m.sub! %r/_+$/, ''
+
+        super unless tag_name 
+
+        __ tag_name, *a, &b
+#--}}}
+      end
+      def xx_which *argv 
+#--{{{
+        @xx_which = nil unless defined? @xx_which
+        if argv.empty?
+          @xx_which
+        else
+          xx_which = @xx_which
+          begin
+            @xx_which = argv.shift 
+            return yield
+          ensure
+            @xx_which = xx_which
+          end
+        end
+#--}}}
+      end
+      def xx_with_doc_in_effect *a, &b
+#--{{{
+        @xx_docs ||= []
+        doc = ::XX::Document::new *a
+        ddoc = doc.doc
+        begin
+          @xx_docs.push doc
+
+          doctype = xx_config_for "doctype", xx_which
+          if doctype
+            unless ddoc.doctype
+              doctype = ::REXML::DocType::new doctype unless 
+                ::REXML::DocType === doctype
+              ddoc << doctype
+            end
+          end
+
+          xmldecl = xx_config_for "xmldecl", xx_which
+          if xmldecl
+            if ddoc.xml_decl == ::REXML::XMLDecl::default
+              xmldecl = ::REXML::XMLDecl::new xmldecl unless
+                ::REXML::XMLDecl === xmldecl
+              ddoc << xmldecl
+              doc.xmldecl = ::REXML::XMLDecl
+            end
+          end
+
+          b.call doc if b
+
+          return doc
+        ensure
+          @xx_docs.pop
+        end
+#--}}}
+      end
+      def xx_doc
+#--{{{
+        @xx_docs.last rescue raise "no xx_doc in effect!"
+#--}}}
+      end
+      def xx_text_ *objects, &b
+#--{{{
+        doc = xx_doc
+
+        text =
+          ::REXML::Text::new("", 
+            respect_whitespace=true, parent=nil
+          )
+
+        objects.each do |object| 
+          text << object.to_s if object
+        end
+
+        doc.create text, &b
+#--}}}
+      end
+      alias_method "t__", "xx_text_"
+      alias_method "text__", "xx_text_"
+      def xx_markup_ *objects, &b
+#--{{{
+        doc = xx_doc
+
+        doc2 = ::REXML::Document::new ""
+
+        objects.each do |object| 
+          (doc2.root ? doc2.root : doc2) << ::REXML::Document::new(object.to_s)
+        end
+
+
+        ret = doc.create doc2, &b
+        puts doc2.to_s
+        STDIN.gets
+        ret
+#--}}}
+      end
+      alias_method "x__", "xx_markup_"
+      alias_method "markup__", "xx_markup_"
+      def xx_any_ *objects, &b
+#--{{{
+        doc = xx_doc
+        nothing = %r/.^/m
+
+        text =
+          ::REXML::Text::new("", 
+            respect_whitespace=true, parent=nil, raw=true, entity_filter=nil, illegal=nothing
+          )
+
+        objects.each do |object| 
+          text << object.to_s if object
+        end
+
+        doc.create text, &b
+#--}}}
+      end
+      alias_method "any__", "xx_any_"
+      alias_method "h__", "xx_any_"
+      alias_method "x__", "xx_any_" # supplant for now
+      def xx_cdata_ *objects, &b
+#--{{{
+        doc = xx_doc
+
+        cdata = ::REXML::CData::new ""
+
+        objects.each do |object| 
+          cdata << object.to_s if object
+        end
+
+        doc.create cdata, &b
+#--}}}
+      end
+      alias_method "cdata__", "xx_cdata_"
+      alias_method "c__", "xx_cdata_"
+      def xx_parse_attributes string
+#--{{{
+        string = string.to_s
+        tokens = string.split %r/,/o
+        tokens.map{|t| t.sub!(%r/[^=]+=/){|key_eq| key_eq.chop << " : "}}
+        xx_parse_yaml_attributes(tokens.join(','))
+#--}}}
+      end
+      alias_method "a__", "xx_parse_attributes"
+      def xx_parse_yaml_attributes string
+#--{{{
+        require "yaml"
+        string = string.to_s
+        string = "{" << string unless string =~ %r/^\s*[{]/o
+        string = string << "}" unless string =~ %r/[}]\s*$/o
+        obj = ::YAML::load string
+        raise ArgumentError, "<#{ obj.class }> not Hash!" unless Hash === obj
+        obj
+#--}}}
+      end
+      alias_method "y__", "xx_parse_yaml_attributes"
+      def xx_class
+#--{{{
+        @xx_class ||= self.class
+#--}}}
+      end
+      def xx_tag_method_name *a, &b 
+#--{{{
+        xx_class.xx_tag_method_name *a, &b
+#--}}}
+      end
+      def xx_define_tmp_method *a, &b 
+#--{{{
+        xx_class.xx_define_tmp_method *a, &b
+#--}}}
+      end
+      def xx_define_tag_method *a, &b 
+#--{{{
+        xx_class.xx_define_tag_method *a, &b
+#--}}}
+      end
+      def xx_remove_tag_method *a, &b 
+#--{{{
+        xx_class.xx_tag_remove_method *a, &b
+#--}}}
+      end
+      def xx_ancestors
+#--{{{
+        raise Error, "no xx_which in effect" unless xx_which
+        xx_class.xx_ancestors xx_which
+#--}}}
+      end
+      def xx_config
+#--{{{
+        xx_class.xx_config
+#--}}}
+      end
+      def xx_config_for *a, &b
+#--{{{
+        xx_class.xx_config_for *a, &b
+#--}}}
+      end
+      def xx_configure *a, &b
+#--{{{
+        xx_class.xx_configure *a, &b
+#--}}}
+      end
+#--}}}
+    end
+
+    module ClassMethods
+#--{{{
+      def xx_tag_method_name m
+#--{{{
+        m = m.to_s
+        tag_method, tag_name = m, m.gsub(%r/_+$/, "")
+        [ tag_method, tag_name ]
+#--}}}
+      end
+      def xx_define_tmp_method m 
+#--{{{
+        define_method(m){ raise NotImplementedError, m.to_s }
+#--}}}
+      end
+      def xx_define_tag_method tag_method, tag_name = nil
+#--{{{
+        tag_method = tag_method.to_s
+        tag_name ||= tag_method.sub(%r/_$/, '')
+
+        module_eval <<-code
+          def #{ tag_method } *a, &b
+            hashes, nothashes = a.partition{|x| Hash === x}
+
+            doc = xx_doc
+            element = ::REXML::Element::new '#{ tag_name }'
+
+            hashes.each{|h| h.each{|k,v| element.add_attribute k.to_s, v}}
+            nothashes.each{|nh| element << ::REXML::Text::new(nh.to_s)}
+
+            doc.create element, &b
+          end
+        code
+        tag_method
+#--}}}
+      end
+      def xx_remove_tag_method tag_method
+#--{{{
+        remove_method tag_method rescue nil
+#--}}}
+      end
+      def xx_ancestors xx_which = self
+#--{{{
+        list = []
+        ancestors.each do |a|
+          list << a if a < xx_which
+        end
+        xx_which.ancestors.each do |a|
+          list << a if a <= Markup
+        end
+        list
+#--}}}
+      end
+      def xx_config
+#--{{{
+        @@xx_config ||= Hash::new{|h,k| h[k] = {}}
+#--}}}
+      end
+      def xx_config_for key, xx_which = nil 
+#--{{{
+        key = key.to_s 
+        xx_which ||= self
+        xx_ancestors(xx_which).each do |a|
+          if xx_config[a].has_key? key
+            return xx_config[a][key]
+          end
+        end
+        nil
+#--}}}
+      end
+      def xx_configure key, value, xx_which = nil 
+#--{{{
+        key = key.to_s
+        xx_which ||= self
+        xx_config[xx_which][key] = value
+#--}}}
+      end
+#--}}}
+    end
+
+    extend ClassMethods
+    include InstanceMethods
+
+    def self::included other, *a, &b
+#--{{{
+      ret = super
+      other.module_eval do
+        include Markup::InstanceMethods
+        extend Markup::ClassMethods
+        class << self
+          define_method("included", Markup::XX_MARKUP_RECURSIVE_INCLUSION_PROC)
+        end
+      end
+      ret
+#--}}}
+    end
+    XX_MARKUP_RECURSIVE_INCLUSION_PROC = method("included").to_proc
+
+    xx_configure "method_missing", XX::PERMISSIVE
+    xx_configure "tags", []
+    xx_configure "doctype", nil
+    xx_configure "xmldecl", nil
+#--}}}
+  end
+
+  module XHTML
+#--{{{
+    include Markup
+    xx_configure "doctype", %(html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd")
+
+    def xhtml_ which = XHTML, *a, &b
+#--{{{
+      xx_which(which) do
+        doc = xx_with_doc_in_effect *a, &b
+        ddoc = doc.doc
+        root = ddoc.root
+        if root and root.name and root.name =~ %r/^html$/i 
+          if root.attribute("lang",nil).nil? or root.attribute("lang",nil).to_s.empty?
+            root.add_attribute "lang", "en"
+          end
+          if root.attribute("xml:lang").nil? or root.attribute("xml:lang").to_s.empty?
+            root.add_attribute "xml:lang", "en"
+          end
+          if root.namespace.nil? or root.namespace.to_s.empty?
+            root.add_namespace "http://www.w3.org/1999/xhtml"
+          end
+        end
+        doc
+      end
+#--}}}
+    end
+    alias_method "xhtml__", "xhtml_"
+
+    module Strict
+#--{{{
+      include XHTML
+      xx_configure "doctype", %(html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd")
+      xx_configure "tags", %w(
+        html head body div span DOCTYPE title link meta style p
+        h1 h2 h3 h4 h5 h6 strong em abbr acronym address bdo blockquote cite q code
+        ins del dfn kbd pre samp var br a base img
+        area map object param ul ol li dl dt dd table
+        tr td th tbody thead tfoot col colgroup caption form input
+        textarea select option optgroup button label fieldset legend script noscript b
+        i tt sub sup big small hr
+      )
+      xx_configure "method_missing", ::XX::STRICT
+
+      def xhtml_ which = XHTML::Strict, *a, &b
+#--{{{
+        super(which, *a, &b)
+#--}}}
+      end
+      alias_method "xhtml__", "xhtml_"
+#--}}}
+    end
+
+    module Transitional
+#--{{{
+      include XHTML
+      xx_configure "doctype", %(html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd")
+      def xhtml_ which = XHTML::Transitional, *a, &b
+#--{{{
+        super(which, *a, &b)
+#--}}}
+      end
+      alias_method "xhtml__", "xhtml_"
+#--}}}
+    end
+#--}}}
+  end
+
+  module HTML4
+#--{{{
+    include Markup
+    xx_configure "doctype", %(html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN")
+ 
+    def html4_ which = HTML4, *a, &b
+#--{{{
+      xx_which(which){ xx_with_doc_in_effect *a, &b }
+#--}}}
+    end
+    alias_method "html4__", "html4_"
+
+    module Strict
+#--{{{
+      include HTML4
+      xx_configure "doctype", %(html PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN")
+      xx_configure "tags", %w(
+        html head body div span DOCTYPE title link meta style p
+        h1 h2 h3 h4 h5 h6 strong em abbr acronym address bdo blockquote cite q code
+        ins del dfn kbd pre samp var br a base img
+        area map object param ul ol li dl dt dd table
+        tr td th tbody thead tfoot col colgroup caption form input
+        textarea select option optgroup button label fieldset legend script noscript b
+        i tt sub sup big small hr
+      )
+      xx_configure "method_missing", ::XX::STRICT
+      def html4_ which = HTML4::Strict, *a, &b
+#--{{{
+        super(which, *a, &b)
+#--}}}
+      end
+      alias_method "html4__", "html4_"
+#--}}}
+    end
+
+    module Transitional
+#--{{{
+      include HTML4
+      xx_configure "doctype", %(html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN")
+      def html4_ which = HTML4::Transitional, *a, &b
+#--{{{
+        super(which, *a, &b)
+#--}}}
+      end
+      alias_method "html4__", "html4_"
+#--}}}
+    end
+#--}}}
+  end
+  HTML = HTML4
+
+  module XML
+#--{{{
+    include Markup
+    xx_configure "xmldecl", ::REXML::XMLDecl::new
+
+    def xml_ *a, &b
+#--{{{
+      xx_which(XML){ xx_with_doc_in_effect *a, &b }
+#--}}}
+    end
+    alias_method "xml__", "xml_"
+#--}}}
+  end
+
+  module Template
+#--{{{
+    class Basic
+#--{{{
+      %w( path inline type object template port pretty ).each{|a| attr_accessor a}
+      def initialize opts = {}, &b
+#--{{{
+        @path = opts['path'] || opts[:path]
+        @inline = opts['inline'] || opts[:inline]
+        @type = opts['type'] || opts[:type]
+        @object = opts['object'] || opts[:object]
+        @pretty = opts['pretty'] || opts[:pretty]
+        @port = opts['port'] || opts[:port] || STDOUT
+
+        bool = lambda{|value| value ? true : false}
+        raise ArgumentError unless(bool[@path] ^ bool[@inline])
+
+        path_init(&b) if @path
+        inline_init(&b) if @inline
+
+        @type =
+          case @type.to_s.downcase.strip
+            when /^xhtml$/
+              XHTML
+            when /^xml$/
+              XML
+            when /^html4$/
+              HTML4
+            else
+              XHTML
+          end
+#--}}}
+      end
+      def path_init &b
+#--{{{
+        @template = IO.read @path
+        @type = @path[%r/\.[^\.]+$/o] || XHTML unless @type
+#--}}}
+      end
+      def inline_init &b
+#--{{{
+        @template = (@inline || b.call).to_s 
+        @type ||= XHTML
+#--}}}
+      end
+      def expand binding, opts = {}
+#--{{{
+        port = opts['port'] || opts[:port] || STDOUT
+        pretty = opts['pretty'] || opts[:pretty]
+
+        object = eval 'self', binding
+
+        unless type === object 
+          __m = type
+          klass = object.class
+          klass.module_eval{ include __m } 
+        end
+
+        doc = eval @template, binding 
+
+        display = pretty ? 'pretty' : 'to_str'
+
+        doc.send display, port
+#--}}}
+      end
+      alias_method "result", "expand"
+#--}}}
+    end
+
+    class File < Basic
+#--{{{
+      def initialize *argv, &b
+#--{{{
+        opts, argv = argv.partition{|arg| Hash === arg}
+        opts = opts.inject{|a,b| a.update b}
+        path = argv.shift
+        raise ArgumentError, "no path" unless path
+        raise ArgumentError, "bad opts" unless Hash === opts or opts.nil? 
+        opts ||= {}
+        opts['path'] = opts[:path] = path.to_s
+        super opts, &b
+#--}}}
+      end
+#--}}}
+    end
+
+    class Inline < Basic
+#--{{{
+      def initialize *argv, &b
+#--{{{
+        opts, argv = argv.partition{|arg| Hash === arg}
+        opts = opts.inject{|a,b| a.update b}
+        inline = argv.shift || b.call
+        raise ArgumentError, "no inline" unless inline
+        raise ArgumentError, "bad opts" unless Hash === opts or opts.nil? 
+        opts ||= {}
+        opts['inline'] = opts[:inline] = inline.to_s
+        super opts, &b
+#--}}}
+      end
+#--}}}
+    end
+#--}}}
+  end
+
+  module Expandable
+#--{{{
+    module InstanceMethods
+#--{{{
+      def xx_template_file *a, &b
+#--{{{
+        template = XX::Template::File.new *a, &b
+        template.object ||= self
+        template
+#--}}}
+      end
+      def xx_template_inline *a, &b
+#--{{{
+        template = XX::Template::Inline.new *a, &b
+        template.object ||= self
+        template
+#--}}}
+      end
+      def xx_expand template, opts = {}
+#--{{{
+        port = opts['port'] || opts[:port] || STDOUT
+        pretty = opts['pretty'] || opts[:pretty]
+        binding = opts['binding'] || opts[:binding]
+
+        type = template.type
+
+        unless type === self 
+          klass = self.class
+          klass.module_eval{ include type } 
+        end
+
+        display = pretty ? 'pretty' : 'to_str'
+
+        Binding.of_caller do |scope|
+          binding ||= eval('binding', scope)
+          doc = eval template.template, binding 
+          doc.send display, port
+        end
+#--}}}
+      end
+      def xx_expand_file *a, &b 
+#--{{{
+        template = xx_template_file *a, &b 
+
+        type = template.type
+        pretty = template.pretty
+        port = template.port
+
+        unless type === self 
+          klass = self.class
+          klass.module_eval{ include type } 
+        end
+
+        display = pretty ? 'pretty' : 'to_str'
+
+        Binding.of_caller do |scope|
+          binding ||= eval('binding', scope)
+          doc = eval template.template, binding 
+          doc.send display, port
+        end
+#--}}}
+      end
+      alias_method "xx_expand_path", "xx_expand_file"
+      alias_method "xx_expand_template", "xx_expand_file"
+      def xx_expand_inline *a, &b 
+#--{{{
+        template = xx_template_inline *a, &b 
+
+        type = template.type
+        pretty = template.pretty
+        port = template.port
+
+        unless type === self 
+          klass = self.class
+          klass.module_eval{ include type } 
+        end
+
+        display = pretty ? 'pretty' : 'to_str'
+
+        Binding.of_caller do |scope|
+          binding ||= eval('binding', scope)
+          doc = eval template.template, binding 
+          doc.send display, port
+        end
+#--}}}
+      end
+      alias_method "xx_expand_string", "xx_expand_inline"
+#--}}}
+    end
+    module ClassMethods
+    end
+    def self.included other
+#--{{{
+      other.instance_eval{ include InstanceMethods }
+      other.extend ClassMethods 
+#--}}}
+    end
+#--}}}
+  end
+
+#--}}}
+end
+
+$__xx_rb__ = __FILE__
+end
+
+
+
+
+
+
+
+
+
+
+#
+# simple examples - see samples/ dir for more complete examples
+#
+
+if __FILE__ == $0
+
+  class Table < ::Array
+    include XX::XHTML::Strict
+    include XX::HTML4::Strict
+    include XX::XML
+
+    def doc 
+      html_{
+        head_{ title_{ "xhtml/html4/xml demo" } }
+
+        div_{
+          h_{ "< malformed html & un-escaped symbols" }
+        }
+
+        t_{ "escaped & text > <" }
+
+        x_{ "<any_valid> xml </any_valid>" }
+
+        div_(:style => :sweet){ 
+          em_ "this is a table"
+
+          table_(:width => 42, :height => 42){
+            each{|row| tr_{ row.each{|cell| td_ cell } } }
+          }
+        }
+
+        script_(:type => :dangerous){ cdata_{ "javascript" } }
+      }
+    end
+    def to_xhtml
+      xhtml_{ doc }
+    end
+    def to_html4
+      html4_{ doc }
+    end
+    def to_xml
+      xml_{ doc }
+    end
+  end
+
+  table = Table[ %w( 0 1 2 ), %w( a b c ) ]
+  
+  methods = %w( to_xhtml to_html4 to_xml )
+
+  methods.each do |method|
+    2.times{ puts "-" * 42 }
+    puts(table.send(method).pretty)
+    puts
+  end
+
+end