wunderbar 0.17.3 → 0.18.0

data/lib/wunderbar/html-methods.rb

@@ -1,6 +1,30 @@
 # Wrapper class that understands HTML
 module Wunderbar
-  class HtmlMarkup < BuilderBase
+  # factored out so that these methods can be overriden (e.g., by opal.rb)
+  class Overridable < BuilderBase
+    def _script(*args, &block)
+      args << {} unless Hash === args.last
+      args.last[:lang] ||= 'text/javascript'
+      args.unshift ScriptNode
+      proxiable_tag! 'script', *args, &block
+    end
+
+    def _style(*args, &block)
+      if args == [:system]
+        args[0] = %{
+          pre._stdin {font-weight: bold; color: #800080; margin: 1em 0 0 0}
+          pre._stdout {font-weight: bold; color: #000; margin: 0}
+          pre._stderr {font-weight: bold; color: #F00; margin: 0}
+        }
+      end
+      args << {} unless Hash === args.last
+      args.last[:type] ||= 'text/css'
+      args.unshift StyleNode
+      proxiable_tag! 'style', *args, &block
+    end
+  end
+
+  class HtmlMarkup < Overridable
     VOID = %w(
       area base br col command embed hr img input keygen
       link meta param source track wbr
@@ -13,9 +37,11 @@ module Wunderbar
       hr noscript ol output p pre section table tfoot ul video
     )
 
+    HEAD = %w(title base link style meta)
+
     def initialize(scope)
       @_scope = scope
-      @x = XmlMarkup.new :scope => scope, :indent => 2, :target => []
+      @x = XmlMarkup.new :scope => scope, :indent => 2
     end
 
     def html(*args, &block)
@@ -23,21 +49,66 @@ module Wunderbar
       args << {} if args.empty?
       if Hash === args.first
         args.first[:xmlns] ||= 'http://www.w3.org/1999/xhtml'
+        @_width = args.first.delete(:_width).to_i if args.first[:_width]
+      end
+
+      if ''.respond_to? :encoding
+        bom = "\ufeff"
+      else
+        bom = "\xEF\xBB\xBF"
       end
-      @_width = args.first.delete(:_width) if Hash === args.first
 
-      @x.text! "\xEF\xBB\xBF"
       @x.declare! :DOCTYPE, :html
-      @x.tag! :html, *args do 
+      html = tag! :html, *args do 
         set_variables_from_params
         instance_eval(&block)
       end
 
-      if @_width
-        self.class.reflow(@x.target!, @_width)
+      pending_head = []
+      pending_body = []
+      head = nil
+      body = nil
+      html.children.each do |child| 
+        next unless child
+        if child.name == 'head'
+          head = child
+        elsif child.name == 'body'
+          body = child
+        elsif HEAD.include? child.name
+          pending_head << child
+        elsif child.name == 'script'
+          if pending_body.empty?
+            pending_head << child
+          else
+            pending_body << child
+          end
+        else
+          pending_body << child
+        end
+      end
+
+      @x.instance_eval {@node = html}
+      head = _head_ if not head
+      body = _body nil if not body
+      html.children.unshift(head.parent.children.delete(head))
+      html.children.push(body.parent.children.delete(body))
+      head.parent = body.parent = html
+      head.children.compact!
+      body.children.compact!
+
+      [ [pending_head, head], [pending_body, body] ].each do |list, node|
+        list.each do |child|
+          html.children.delete(child)
+          node.add_child child
+        end
+      end
+
+      if not head.children.any? {|child| child.name == 'title'}
+        h1 = body.children.find {|child| child.name == 'h1'}
+        head.add_child Node.new('title', h1.text) if h1 and h1.text
       end
 
-      @x.target!.join
+      bom + @x.target!
     end
 
     def _html(*args, &block)
@@ -45,7 +116,7 @@ module Wunderbar
     end
 
     def method_missing(name, *args, &block)
-      if name.to_s =~ /^_(\w+)(!|\?|)$/
+      if name =~ /^_(\w+)(!|\?|)$/
         name, flag = $1, $2
       elsif @_scope and @_scope.respond_to? name
         return @_scope.__send__ name, *args, &block
@@ -56,69 +127,26 @@ module Wunderbar
       end
 
       if name.sub!(/_$/,'')
-        @x.margin!
+        @x.spaced!
         return __send__ "_#{name}", *args, &block if respond_to? "_#{name}"
       end
 
-      if flag != '!'
-        if %w(script style).include?(name)
-          if String === args.first and not block
-            text = args.shift
-            if !text.include? '&' and !text.include? '<'
-              block = Proc.new do
-                @x.indented_data!(text)
-              end
-            elsif name == 'style'
-              block = Proc.new do
-                @x.indented_data!(text, "/*<![CDATA[*/", "/*]]>*/")
-              end
-            else
-              block = Proc.new do
-                @x.indented_data!(text, "//<![CDATA[", "//]]>")
-              end
-            end
-          end
-
-          args << {} if args.length == 0
-          if Hash === args.last
-            args.last[:lang] ||= 'text/javascript' if name == 'script'
-            args.last[:type] ||= 'text/css' if name == 'style'
-          end
-        end
-
-        # ensure that non-void elements are explicitly closed
-        if not block and not VOID.include?(name)
-          args[0] = '' if args.length > 1 and args.first == nil
-          symbol = (args.shift if args.length > 0 and Symbol === args.first)
-          if args.length == 0 or (args.length == 1 and Hash === args.first)
-            args.unshift ''
-          end
-          args.unshift(symbol) if symbol
-        end
+      name = name.to_s.gsub('_', '-')
 
+      if flag != '!'
         if String === args.first and args.first.respond_to? :html_safe?
           if args.first.html_safe? and not block and args.first =~ /[>&]/
             markup = args.shift
             block = Proc.new {_ {markup}}
           end
         end
-
-        if Hash === args.last
-          # remove attributes with nil, false values
-          args.last.delete_if {|key, value| !value}
-
-          # replace boolean 'true' attributes with the name of the attribute
-          args.last.each {|key, value| args.last[key]=key if value == true}
-        end
       end
 
       if flag == '!'
-        @x.disable_indentation! do
-          @x.tag! name, *args, &block
-        end
+        @x.compact!(@_width) { tag! name, *args, &block }
       elsif flag == '?'
         # capture exceptions, produce filtered tracebacks
-        @x.tag!(name, *args) do
+        tag!(name, *args) do
           begin
             block.call
           rescue ::Exception => exception
@@ -127,14 +155,44 @@ module Wunderbar
             _exception exception, options
           end
         end
-      else
-        target = @x.tag! name, *args, &block
-        if block and %w(script style).include?(name)
-          if %w{//]]> /*]]>*/}.include? target[-4]
-            target[-4], target[-3] = target[-3], target[-4]
+      elsif Wunderbar.templates.include? name
+        x = self.class.new({})
+        instance_variables.each do |ivar|
+          x.instance_variable_set ivar, instance_variable_get(ivar)
+        end
+        if Hash === args.last
+          args.last.each do |name, value|
+            x.instance_variable_set "@#{name}", value
           end
         end
-        target
+        save_yield = Wunderbar.templates['yield']
+        begin
+          Wunderbar.templates['yield'] = block if block
+          x.instance_eval &Wunderbar.templates[name]
+        ensure
+          Wunderbar.templates['yield'] = save_yield
+          Wunderbar.templates.delete 'yield' unless save_yield
+        end
+      else
+        tag! name, *args, &block
+      end
+    end
+
+    def tag!(name, *args, &block)
+      node = @x.tag! name, *args, &block
+      if !block and args.empty?
+        CssProxy.new(self, node)
+      else
+        node
+      end
+    end
+
+    def proxiable_tag!(name, *args, &block)
+      node = @x.tag! name, *args, &block
+      if !block
+        CssProxy.new(self, node)
+      else
+        node
       end
     end
 
@@ -157,9 +215,9 @@ module Wunderbar
         end
    
         if traceback_class
-          @x.tag! :pre, text, :class=>traceback_class
+          tag! :pre, text, :class=>traceback_class
         else
-          @x.tag! :pre, text, :style=>traceback_style
+          tag! :pre, text, :style=>traceback_style
         end
       else
         super
@@ -167,8 +225,8 @@ module Wunderbar
     end
 
     def _head(*args, &block)
-      @x.tag!('head', *args) do
-        @x.tag! :meta, :charset => 'utf-8'
+      tag!('head', *args) do
+        tag! :meta, :charset => 'utf-8'
         block.call if block
         instance_eval &Wunderbar::Asset.declarations
       end
@@ -177,7 +235,7 @@ module Wunderbar
     def _p(*args, &block)
       if args.length >= 1 and String === args.first and args.first.include? "\n"
         text = args.shift
-        @x.tag! :p, *args do
+        tag! :p, *args do
           @x.indented_text! text
         end
       else
@@ -188,7 +246,7 @@ module Wunderbar
     def _svg(*args, &block)
       args << {} if args.empty?
       args.first['xmlns'] = 'http://www.w3.org/2000/svg' if Hash === args.first
-      @x.proxiable_tag! :svg, *args, &block
+      proxiable_tag! :svg, *args, &block
     end
 
     def _math(*args, &block)
@@ -196,16 +254,46 @@ module Wunderbar
       if Hash === args.first
         args.first['xmlns'] = 'http://www.w3.org/1998/Math/MathML'
       end
-      @x.proxiable_tag! :math, *args, &block
+      proxiable_tag! :math, *args, &block
     end
     
     def _pre(*args, &block)
       args.first.chomp! if String === args.first and args.first.end_with? "\n"
-      @x.disable_indentation! { @x.tag! :pre, *args, &block }
+      @x.compact!(@_width) { tag! :pre, *args, &block }
+    end
+
+    def _ul(*args, &block)
+      iterable = args.first.respond_to? :each
+      if iterable and (args.length > 1 or not args.first.respond_to? :to_hash)
+        list = args.shift.dup
+        tag!(:ul, *args) {list.each {|arg| _li arg }}
+      else
+        super
+      end
+    end
+
+    def _ol(*args, &block)
+      iterable = args.first.respond_to? :each
+      if iterable and (args.length > 1 or not args.first.respond_to? :to_hash)
+        list = args.shift
+        tag!(:ol, *args) {list.each {|arg| _li arg }}
+      else
+        super
+      end
+    end
+
+    def _tr(*args, &block)
+      iterable = args.first.respond_to? :each
+      if iterable and (args.length > 1 or not args.first.respond_to? :to_hash)
+        list = args.shift
+        tag!(:tr, *args) {list.each {|arg| _td arg }}
+      else
+        super
+      end
     end
 
     def _!(text)
-      @x.text! text.to_s
+      @x.text! text.to_s.chomp
     end
 
     def _(text=nil, &block)
@@ -244,7 +332,7 @@ module Wunderbar
     end
 
     def clear!
-      @x.target!.clear
+      @x.clear!
     end
 
     def self.flatten?(children)
@@ -264,65 +352,5 @@ module Wunderbar
       end
       flatten
     end
-
-    # reflow long lines
-    def self.reflow(stream, width)
-      source = stream.slice!(0..-1)
-      indent = col = 0
-      breakable = true
-      pre = false
-      while not source.empty?
-        token = source.shift
-        indent = token[/^ */].length if col == 0
-
-        if token.start_with? '<'
-          breakable = false
-          pre = true if token == '<pre'
-        end
-
-        # flow text
-        while token.length + col > width and breakable and not pre
-          break if token[0...-1].include? "\n"
-          split = token.rindex(' ', [width-col,0].max) || token.index(' ')
-          break unless split
-          break if col+split < indent+width/2
-          stream << token[0...split] << "\n" << (' '*indent)
-          col = indent
-          token = token[split+1..-1]
-        end
-
-        # break around tags
-        if token.end_with? '>'
-          if col > indent + 4 and stream[-2..-1] == ['<br', '/']
-            stream << token << "\n"
-            col = 0
-            token = ' '*indent
-            source[0] = source.first.lstrip unless source.empty?
-          elsif col > width and not pre
-            # break on previous space within text
-            pcol = col
-            stream.reverse_each do |xtoken|
-              break if xtoken.include? "\n"
-              split = xtoken.rindex(' ')
-              breakable = false if xtoken.end_with? '>'
-              if breakable and split
-                col = col - pcol + xtoken.length - split + indent
-                xtoken[split] = "\n#{' '*indent}" 
-                break
-              end
-              breakable = true if xtoken.start_with? '<'
-              pcol -= xtoken.length
-              break if pcol < (width + indent)/2
-            end
-          end
-          breakable = true
-          pre = false if token == '</pre>'
-        end
-
-        stream << token
-        col += token.length
-        col = 0 if token.end_with? "\n"
-      end
-    end
   end
 end

data/lib/wunderbar/node.rb

@@ -0,0 +1,208 @@
+module Wunderbar
+  class Node
+    attr_accessor :name, :text, :attrs, :node, :children, :parent
+
+    VOID = %w(
+      area base br col command embed hr img input keygen
+      link meta param source track wbr
+    )
+
+    ESCAPE = {
+      "'" => ''',
+      '&' => '&',
+      '"' => '"',
+      '<' => '&lt;',
+      '>' => '&gt;',
+    }
+
+    def initialize(name, *args)
+      @name = name
+      @text = nil
+      @attrs = {}
+      @children = []
+      @name += args.shift.inspect if Symbol === args.first
+      @attrs = args.pop.to_hash if args.last.respond_to? :to_hash
+      @text = args.shift.to_s unless args.empty?
+    end
+
+    def method_missing(*args)
+      if args.length == 0
+        attrs[:class] = (attrs[:class].to_s.split(' ') + [name]).join(' ')
+      else
+        name = args.first.to_s
+        err = NameError.new "undefined local variable or method `#{name}'", name
+        err.set_backtrace caller
+        raise err
+      end
+    end
+
+    def add_child(child)
+      @children << child
+      child.parent = self
+    end
+
+    def add_text(text)
+      @children << text.to_s.gsub(/[&<>]/,ESCAPE)
+    end
+
+    def walk(result, indent, options)
+      indent += options[:indent] if indent and parent
+      first = true
+      spaced = false
+      children.each do |child| 
+        next unless child
+        result << '' if (spaced or SpacedNode === child) and not first
+        if String === child
+          result << child
+        else
+          child.serialize(options, result, indent)
+        end
+        first = false
+        spaced = (SpacedNode === child)
+      end
+    end
+
+    def serialize(options = {}, result = [], indent = '')
+      line = "#{indent}<#{name}"
+
+      attrs.each do |name, value| 
+        next unless value
+        name = name.to_s.gsub('_','-') if Symbol === name
+        value=name if value==true
+        line += " #{name}=\"#{value.to_s.gsub(/[&\"<>]/,ESCAPE)}\""
+      end
+
+      if children.empty? 
+        if text
+          if options[:pre]
+            line += ">#{options[:pre]}#{text}#{options[:post]}</#{name}>"
+          else
+            line += ">#{text.to_s.gsub(/[&<>]/,ESCAPE)}</#{name}>"
+          end
+        elsif VOID.include? name.to_s
+          line += "/>"
+        else
+          line += "></#{name}>"
+        end
+      elsif CompactNode === self
+        work = []
+        walk(work, nil, options)
+        if @width
+          line += ">"
+          (work+["</#{name}>"]).each do |node|
+            if line.length + node.length > @width
+              result << line.rstrip
+              line = indent
+            end
+            line += node
+          end
+        else
+          line += ">#{work.join}</#{name}>"
+        end
+      else
+        result <<  line+">#{options[:pre]}" if parent
+
+        walk(result, indent, options) unless children.empty?
+
+        line = "#{indent}#{options[:post]}</#{name}>"
+      end
+
+      result << line if parent
+      result
+    end
+  end
+
+  class CommentNode
+    def initialize(text)
+      @text = text
+    end
+
+    def serialize(options, result, indent)
+      result << "#{indent}<!-- #{@text} -->"
+      result
+    end
+  end
+
+  class DocTypeNode
+    def initialize(*args)
+      @declare = args.shift
+      @name = args.shift
+    end
+
+    def serialize(options, result, indent)
+      result << "<!#{@declare} #{@name.to_s}>"
+      result
+    end
+  end
+
+  class CDATANode < Node
+    def self.normalize(data, indent)
+      data = data.sub(/\n\s*\Z/, '').sub(/\A\s*\n/, '')
+
+      unindent = data.sub(/s+\Z/,'').scan(/^ *\S/).map(&:length).min || 0
+
+      before  = ::Regexp.new('^'.ljust(unindent))
+      node = @node
+      data.gsub! before, indent
+      data.gsub! /^#{indent}$/, '' if unindent == 0
+      data
+    end
+
+    def serialize(options = {}, result = [], indent='')
+      if @text and @text.include? "\n"
+        tindent = (indent ? "#{indent}#{options[:indent]}" : indent)
+        children.unshift CDATANode.normalize(@text, tindent).rstrip
+        @text = nil
+      end
+
+      if @text and @text =~ /[<^>]/
+        indent += '  ' if indent
+        children.unshift @text.gsub(/^/, indent).gsub(/^ +$/,'').rstrip
+        @text = nil
+        super(options.merge(pre: pre, post: post), result, indent)
+      elsif children && children.any? {|node| String===node && node =~ /[<^>]/}
+        super(options.merge(pre: pre, post: post), result, indent)
+      else
+        super
+      end
+    end
+
+    def add_text(text)
+      @children << text
+    end
+  end
+
+  class IndentedTextNode < Node
+    def serialize(options, result, indent)
+      if indent
+        text = CDATANode.normalize(name, indent)
+      else
+        text = name
+      end
+
+      result << text.to_s.gsub(/[&<>]/,ESCAPE)
+    end
+  end
+
+  class ScriptNode < CDATANode
+    def pre; "//<![CDATA["; end
+    def post; "//]]>"; end
+  end
+
+  class StyleNode < CDATANode
+    def pre; "/*<![CDATA[*/"; end
+    def post; "/*]]>*/"; end
+  end
+
+  module CompactNode
+    def width=(value)
+      @width = value
+    end
+    def width
+      @width
+    end
+  end
+
+  module SpacedNode; end
+
+end