www_app 1.3.0 → 2.0.0

data/lib/www_app/TO.rb

@@ -0,0 +1,897 @@
+require 'mustache'
+require 'escape_escape_escape'
+
+# ===================================================================
+# === Symbol customizations: ========================================
+# ===================================================================
+class Symbol
+
+  def to_mustache *args
+    WWW_App::Clean.mustache *args, self
+  end
+
+end # === class Symbol
+# ===================================================================
+
+# ===================================================================
+# === Mustache customizations: ======================================
+# ===================================================================
+Mustache.raise_on_context_miss = true
+
+class Mustache
+
+  def render(data = template, ctx = {})
+    ctx = data
+    tpl = templateify(template)
+
+    begin
+      context.push(ctx)
+      tpl.render(context)
+    ensure
+      context.pop
+    end
+  end # === def render
+
+  class Generator
+
+    alias_method :w_syms_on_fetch, :on_fetch
+
+    def on_fetch(names)
+      if names.length == 2
+        "ctx[#{names.first.to_sym.inspect}, #{names.last.to_sym.inspect}]"
+      else
+        w_syms_on_fetch(names)
+      end
+    end
+
+  end # === class Generator
+
+  class Context
+
+    def fetch *args
+      raise ContextMiss.new("Can't find: #{args.inspect}") if args.size != 2
+
+      meth, key = args
+
+      @stack.each { |frame|
+        case
+        when frame.is_a?(Hash) && meth == :coll && !frame.has_key?(key)
+          return false
+
+        when frame.is_a?(Hash) && meth == :coll && frame.has_key?(key)
+            target = frame[key]
+            if target == true || target == false  || target == nil || target.is_a?(Array) || target.is_a?(Hash)
+              return target
+            end
+            fail "Invalid value: #{key.inspect} (#{key.class})"
+
+        when frame.is_a?(Hash) && frame.has_key?(key)
+          return ::Escape_Escape_Escape.send(meth, frame[key])
+
+        end
+      }
+
+      raise ContextMiss.new("Can't find .#{meth}(#{key.inspect})")
+    end
+
+    # NOTE: :alias_method has to go after the re-definition of
+    # :fetch or else it uses the original :fetch method/definition.
+    alias_method :[], :fetch 
+
+
+  end # === class Context
+
+end # === class Mustache
+# ===================================================================
+
+class WWW_App
+
+  class Clean
+
+    MUSTACHE_Regex = /\A[a-z0-9\_\.]+\z/i
+    PERIOD = '.'.freeze
+
+    class << self
+
+      def mustache *args
+        case args.size
+        when 2
+          meth, val = args
+          escape_it = false
+        when 3
+          escape_it, meth, val = args
+        else
+          fail ::ArgumentError, "Unknown args: #{args}"
+        end
+
+        v = meth.to_s + PERIOD + val.to_s
+        fail "Unknown chars: #{args.inspect}" unless v[MUSTACHE_Regex]
+
+        if escape_it
+          "!{ #{v} }!"
+        else
+          "{{{ #{v} }}}"
+        end
+      end
+
+      def method_missing name, *args
+        ::Escape_Escape_Escape.send(name, *args)
+      end
+
+    end # === class << self
+  end # === class Clean
+
+  module TO
+    COMMA         = ", ".freeze
+    SPACE         = " ".freeze
+    NOTHING       = "".freeze
+    GEM_PATH      = File.dirname(__FILE__).sub('lib/www_app'.freeze, NOTHING)
+    VERSION       = File.read(GEM_PATH + '/VERSION').strip
+    JS_FILE_PATHS = begin
+                      public = "#{GEM_PATH}/lib/public"
+                      all = Dir.glob("#{public}/**/*.{map,js}").map { |path|
+                        "/www_app-#{VERSION}/#{path.gsub("#{public}/", NOTHING)}"
+                      }
+                      special = all.select { |f| f[/(instruct.js|www_app.js)$/] }
+                      filtered = all.reject { |f| special.include?(f) }
+                      filtered + special
+                    end
+
+    INVALID_SCRIPT_TYPE_CHARS = /[^a-z0-9\-\/\_]+/
+
+    KEY_REQUIRED = proc { |hash, k|
+      fail "Key not set: #{k.inspect}"
+    }
+
+    def to_raw_text
+      str    = ""
+      indent = 0
+      print_tag = lambda { |t|
+        info          = t.select { |n| [:id, :class, :closed, :pseudo].include?( n ) }
+        info[:parent] = t[:parent] && t[:parent][:tag_name]
+
+        str += "#{" " * indent}#{t[:tag_name].inspect} -- #{info.inspect.gsub(/\A\{|\}\Z/, '')}\n"
+        indent += 1
+        if t[:children]
+          t[:children].each { |c|
+            str << print_tag.call(c)
+          }
+        end
+        indent -= 1
+      }
+
+      @tags.each { |t| print_tag.call(t) }
+      str
+    end
+
+    def to_html *args
+      return @mustache.render(*args) if instance_variable_defined?(:@mustache)
+
+      final     = ""
+      indent    = 0
+      todo      = @tags.dup
+      last      = nil
+      stacks    = {:js=>[], :script_tags=>[]}
+      last_open = nil
+
+      script_libs_added = false
+
+      doc = [
+        doc_type   = {:tag_name=>:doc_type , :text => "<!DOCTYPE html>"},
+        html       = {:tag_name=>:html     , :children=>[
+          head     = {:tag_name=>:head     , :lang=>'en', :children=>[]},
+          body     = {:tag_name=>:body     , :children=>[]}
+        ]}
+      ]
+      style_tags = {:tag_name => :style_tags, :children => []}
+
+      tags = @tags.dup
+      while (t = tags.shift)
+        t_name = t[:tag_name]
+        parent = t[:parent]
+
+        case # ==============
+        when t_name == :title && !parent
+          fail "Title already set." if head[:children].detect { |c| c[:tag_name] == :title }
+          head[:children] << t
+
+        when t_name == :meta
+          head[:children] << t
+
+        when t_name == :style
+          style_tags[:children] << t
+
+        when t_name == :_ && !parent
+          body[:css] = (body[:css] || {}).merge(t[:css]) if t[:css]
+          body[:class] = (body[:class] || []).concat(t[:class]) if t[:class]
+
+          if t[:id]
+            fail ":body already has id: #{body[:id].inspect}, #{t[:id]}" if body[:id]
+            body[:id]  = t[:id] 
+          end
+
+          if t[:children]
+            body[:children].concat t[:children]
+            tags = t[:children].dup.concat(tags)
+          end
+
+        else # ==============
+          if !parent
+            body[:children] << t
+          end
+
+          if t[:css]
+            style_tags[:children] << t
+          end
+
+          if t[:children]
+            tags = t[:children].dup.concat(tags)
+          end
+
+          if t_name == :script
+            stacks[:script_tags] << t
+          end
+
+          if t_name == :js
+            stacks[:js].concat [css_selector(t[:parent])].concat(t[:value])
+          end
+
+        end # === case ========
+      end # === while
+
+      if body[:css] && !body[:css].empty?
+        style_tags[:children] << body
+      end
+
+      is_fragment = stacks[:script_tags].empty? && stacks[:js].empty? && style_tags[:children].empty? && head[:children].empty? && body.values_at(:css, :id, :class).compact.empty?
+
+      if is_fragment
+        doc = body[:children]
+
+      else # is doc
+        head[:children] << style_tags
+        content_type = head[:children].detect { |t| t[:tag_name] == :meta && t[:http_equiv] && t[:http_equiv].downcase=='Content-Type'.downcase }
+        if !content_type
+          head[:children].unshift(
+            {:tag_name=>:meta, :http_equiv=>'Content-Type', :content=>"text/html; charset=UTF-8"}
+          )
+        end
+
+      end # if is_fragment
+
+      todo = doc.dup
+      while (tag = todo.shift)
+        t_name = tag.is_a?(Hash) && tag[:tag_name]
+
+        case
+
+        when tag == :new_line
+          final << NEW_LINE
+
+        when tag == :open
+          attributes = stacks.delete :attributes
+
+          tag_sym = todo.shift
+
+          if [:script].include?(tag_sym) || (todo.first != :close && !indent.zero? && !HTML::NO_NEW_LINES.include?(last_open))
+            final << NEW_LINE << SPACES(indent)
+          end
+
+          if HTML::SELF_CLOSING_TAGS.include?(tag_sym)
+            final << (
+              attributes ?
+              "<#{tag_sym} #{attributes} />\n" :
+              "<#{tag_sym} />\n"
+            )
+            if todo.first == :close && todo[1] == tag_sym
+              todo.shift
+              todo.shift
+            end
+
+          else # === has closing tag
+            if attributes
+              final << "<#{tag_sym} #{attributes}>"
+            else
+              final << "<#{tag_sym}>"
+            end
+          end # === if HTML
+
+          last = indent
+          indent += 2
+          last_open = tag_sym
+
+
+        when tag == :close
+          indent -= 2
+          if last != indent
+            final << SPACES(indent)
+          end
+          last = indent
+          final << "</#{todo.shift}>"
+
+        when tag == :clean_attrs
+          attributes = todo.shift
+          target     = todo.shift
+          tag_name   = target[:tag_name]
+
+          attributes.each { |attr, val|
+            attributes[attr] = case
+
+                               when attr == :src && tag_name == :script
+                                 fail ::ArgumentError, "Invalid type: #{val.inspect}" unless val.is_a?(String)
+                                 Clean.relative_href val
+
+                               when attr == :type && tag_name == :script
+                                 clean = val.gsub(INVALID_SCRIPT_TYPE_CHARS, '')
+                                 clean = 'text/unknown' if clean.empty?
+                                 clean
+
+                               when attr == :type && val == :hidden
+                                 'hidden'
+
+                               when attr == :href && tag_name == :a
+                                 if val.is_a? Symbol
+                                   Clean.mustache :href, val
+                                 else
+                                   Clean.href val
+                                 end
+
+                               when [:action, :src, :href].include?(attr)
+                                 Clean.relative_href(val)
+
+                               when attr == :id
+                                 Clean.html_id(val.to_s)
+
+                               when attr == :class
+                                 val.map { |name|
+                                   Clean.css_class_name(name.to_s)
+                                 }.join(" ".freeze)
+
+                               when tag_name == :style && attr == :type
+                                 'text/css'
+
+                               when ::WWW_App::HTML::TAGS_TO_ATTRIBUTES[tag_name].include?(attr)
+                                 Clean.html(val)
+
+                               else
+                                 fail "Invalid attr: #{attr.inspect}"
+
+                               end # case attr
+
+          } # === each attr
+
+          stacks[:attributes] = attributes.inject([]) { |memo, (k,v)|
+            memo << "#{k}=\"#{v}\""
+            memo
+          }.join " ".freeze
+
+        when t_name == :doc_type
+          if tag[:text] == "<!DOCTYPE html>"
+            final << tag[:text]
+            final << NEW_LINE
+          else
+            fail "Unknown doc type: #{tag[:text].inspect}"
+          end
+
+        when t_name == :text
+          final.<<(
+            tag[:skip_escape] ?
+            tag[:value] :
+            Clean.html(tag[:value])
+          )
+
+
+        when t_name == :meta
+          case
+          when tag[:http_equiv]
+            key_name    = "http-equiv"
+            key_content = tag[:http_equiv].gsub(/[^a-zA-Z\/\;\ 0-9\=\-]+/, '')
+            content     = tag[:content].gsub(/[^a-zA-Z\/\;\ 0-9\=\-]+/, '')
+          else
+            fail ArgumentError, tag.keys.inspect
+          end
+
+          final << (
+            %^#{SPACES(indent)}<meta #{key_name}="#{key_content}" content="#{content}" />^
+          )
+
+        when t_name == :html       # === :html tag ================
+          todo = [
+            :clean_attrs, {:lang=>(tag[:lang] || 'en')}, tag,
+            :open, :html
+          ].concat(tag[:children]).concat([:new_line, :close, :html]).concat(todo)
+
+        when t_name == :head       # === :head tag =================
+          todo = [ :open, :head, :new_line ].
+            concat(tag[:children] || []).
+            concat([:new_line, :close, :head]).
+            concat(todo)
+
+        when t_name == :title && !parent(tag)
+          todo = [
+            :open, :title
+          ].concat(tag[:children]).concat([:close, :title]).concat(todo)
+
+        when t_name == :_       # =============== :_ tag ========
+          nil # do nothing
+
+        when t_name == :js
+          next
+
+        when t_name == :script  # =============== :script tag ===
+
+          attrs = tag.select { |k, v|
+            k == :src || k == :type || k == :class
+          }
+
+          new_todo = []
+
+          if attrs[:src] && !script_libs_added
+            new_todo << {:tag_name=>:js_to_script_tag}
+            script_libs_added = true
+          end
+
+          new_todo.concat [
+            :clean_attrs, attrs, tag,
+            :open, :script,
+          ]
+
+          new_todo.concat(tag[:children]) if tag[:children]
+
+          if tag[:children] && !tag[:children].empty? && tag[:children].first[:tag_name] != :text && tag[:children].last[:tag_name] != :text
+            new_todo << :new_line
+          end
+
+          new_todo.concat [
+            :close, :script
+          ].concat(todo)
+
+          todo = new_todo
+
+        when t_name == :js_to_script_tag
+          next if stacks[:js].empty? && stacks[:script_tags].empty?
+          stacks[:clean_text] ||= lambda { |raw_x|
+            x = case raw_x
+                when ::Symbol, ::String
+                  Clean.html(raw_x.to_s)
+                when ::Array
+                  raw_x.map { |x| stacks[:clean_text].call x }
+                when ::Numeric
+                  x
+                else
+                  fail "Unknown type for json: #{raw_x.inspect}"
+                end
+          }
+
+          script_tag = {:tag_name=>:script}.freeze
+
+          new_todo = []
+          JS_FILE_PATHS.each { |path|
+            new_todo.concat [
+              :clean_attrs, {:src=>path}, script_tag,
+              :open, :script,
+              :close, :script
+            ]
+          }
+
+          clean_vals = stacks[:js].map { |raw_x| stacks[:clean_text].call(raw_x) }
+          content = <<-EOF
+            \n#{SPACES(indent)}WWW_App.run( #{::Escape_Escape_Escape.json_encode(clean_vals)} );
+          EOF
+
+          new_todo.concat [
+            :clean_attrs, {:type=>'application/javascript'}, script_tag,
+            :open, :script,
+            {:tag_name=>:text, :skip_escape=>true, :value=> content },
+            :close, :script
+          ]
+
+          todo = new_todo.concat(todo)
+
+        when tag == :javascript
+          vals = todo.shift
+
+        when tag == :to_json
+          vals = todo.shift
+          ::Escape_Escape_Escape.json_encode(to_clean_text(:javascript, vals))
+
+
+        when t_name == :style
+          next
+
+        when t_name == :style_tags # =============== <style ..> TAG =================
+          next if tag[:children].empty?
+
+          style_and_other_tags = tag[:children].dup
+          flatten = []
+
+          # === flatten groups
+          #  style
+          #    div, span {
+          #      a:link, a:visited {
+          #  --->
+          #  style
+          #    div a:link, div a:visited, span a:link, span a:visited  {
+          #
+          prev = nil
+
+          while e = style_and_other_tags.shift
+            case
+            when e[:tag_name] == :style
+              style_and_other_tags = e[:children].dup.concat(style_and_other_tags)
+
+            when e[:tag_name] == :group
+              style_and_other_tags = e[:children].dup.concat(style_and_other_tags)
+              prev = nil
+              flatten << e
+
+            when parent?(e, :group)
+              if e[:__]
+                e[:__children] = []
+              end
+
+              if prev && prev[:__]
+                prev[:__children] << e
+                e[:__parent] = prev
+              end
+              prev = e
+
+            else
+              flatten << e
+
+            end # === case
+          end # === while
+
+          todo = [
+            :clean_attrs, {:type=>'text/css'}, {:tag_name=>:style},
+            :open, :style,
+            :flat_style_groups, flatten,
+            :close, :style
+          ].concat(todo)
+
+        when tag == :flat_style_groups
+
+          indent += 2
+          css_final = ""
+          flatten   = todo.shift
+
+          #
+          # Each produces:
+          #
+          #   selectors {
+          #     escaped/sanitized css;
+          #   }
+          #
+          flatten.each { |style|
+            next if !style[:css] || style[:css].empty?
+
+            css_final << "\n" << SPACES(indent) << css_selector(style, :full) << " {\n".freeze
+
+            the_css = style[:css] || (parent?(style, :group) && style[:parent][:css])
+            if the_css
+              indent += 2
+              the_css.each { |raw_k, raw_val|
+                name = begin
+                          clean_k = ::WWW_App::Clean.css_attr(raw_k.to_s.gsub('_','-'))
+                          fail("Invalid name for css property name: #{raw_k.inspect}") if !clean_k || clean_k.empty?
+                          clean_k
+                        end
+
+                raw_val  = raw_val.is_a?(Array) ? raw_val.join(COMMA) : raw_val.to_s
+
+                v = case
+
+                    when name[IMAGE_AT_END]
+                      case raw_val
+                      when 'inherit', 'none'
+                        raw_val
+                      else
+                        "url(#{Clean.href(raw_val)})"
+                      end
+
+                    when ::WWW_App::CSS::PROPERTIES.include?(raw_k)
+                      Clean.css_value raw_val
+
+                    else
+                      fail "Invalid css attr: #{name.inspect}"
+
+                    end # === case
+
+                css_final << SPACES(indent) << "#{name}: #{v};\n"
+              } # === each style
+              indent -= 2
+            end # === if style[:css]
+
+            css_final << SPACES(indent) << "}\n".freeze << SPACES(indent - 2)
+          }
+
+          indent -= 2
+          todo = [
+            {:tag_name=>:text, :skip_escape=>true, :value=>css_final}
+          ].concat(todo)
+
+        when tag == :script # ============
+          h = vals
+
+          if h[:tag] == :script && h[:content] && !h[:content].empty?
+            return <<-EOF
+              <script type="text/css">
+                WWW_App.run(
+                  #{to_clean_text :to_json, h[:content]}
+                );
+              </script>
+            EOF
+          end
+
+          html = h[:childs].map { |tag_index|
+            to_clean_text(:html, @tag_arr[tag_index])
+          }.join(NEW_LINE).strip
+
+          return unless  h[:render?]
+
+          if html.empty? && h[:text]
+            html = if h[:text].is_a?(::Symbol)
+                     h[:text].to_mustache(:html)
+                   else
+                     if h[:text].is_a?(::Hash)
+                       if h[:text][:escape] == false
+                         h[:text][:value]
+                       else
+                         Clean.html(h[:text][:value].strip)
+                       end
+                     else
+                       Clean.html(h[:text].strip)
+                     end
+                   end
+          end # === if html.empty?
+
+          (html = nil) if html.empty?
+
+          case
+          when h[:tag] == :render_if
+            key   = h[:attrs][:key]
+            open  = "{{# coll.#{key} }}"
+            close = "{{/ coll.#{key} }}"
+
+          when h[:tag] == :render_unless
+            key   = h[:attrs][:key]
+            open  = "{{^ coll.#{key} }}"
+            close = "{{/ coll.#{key} }}"
+
+          when Methods[:elements].include?(h[:tag])
+            open  = "<#{h[:tag]}#{to_clean_text(:attrs, h)}"
+            if NO_END_TAGS.include?(h[:tag])
+              open += ' />'
+              close = nil
+            else
+              open += '>'
+              close = "</#{h[:tag]}>"
+            end
+
+          else
+            fail "Unknown html tag: #{h[:tag].inspect}"
+
+          end # === case h[:tag]
+
+          if h[:tag]
+            [open, html, close].compact.join
+          else
+            html
+          end # === if
+
+        when t_name && ::WWW_App::HTML::TAGS.include?(t_name) # === HTML tags =====
+
+          # ================================
+          # === Save this for last to allow
+          # certain tags
+          # to be over-riddent,
+          # like :script
+          # ================================
+
+          attrs = {}
+          attrs.default KEY_REQUIRED
+
+          new_todo = []
+          t2a = ::WWW_App::HTML::TAGS_TO_ATTRIBUTES
+
+          tag.each { |attr_name, v|
+            if t2a[:all].include?(attr_name) || (t2a[tag[:tag_name]] && t2a[tag[:tag_name]].include?(attr_name))
+              attrs[attr_name] = v
+            end
+          }
+
+          if !attrs.empty?
+            new_todo.concat [:clean_attrs, attrs, tag]
+          end
+
+          new_todo.concat [:open, tag[:tag_name]]
+
+          if tag[:children] && !tag[:children].empty?
+            new_todo.concat tag[:children]
+            if tag[:children].detect { |t| HTML::TAGS.include?(t[:tag_name]) }
+              new_todo << :new_line
+            end
+          end
+          new_todo.concat [:close, tag[:tag_name]]
+          todo = new_todo.concat(todo)
+
+        else
+          fail "Unknown: #{tag.inspect[0,30]}"
+        end # === case
+      end # === while
+
+      final
+
+      @mustache ||= begin
+                      mustache = ::Mustache.new
+                      mustache.template = Clean.clean_utf8(final)
+                      mustache
+                    end
+
+      to_html(*args)
+    end # === to_html
+
+    module OLD
+      #
+      # Examples
+      #    dom_id             -> the current dom id of the current element
+      #    dom_id :default    -> if no dom it, set/get default of current element
+      #    dom_id {:element:} -> dom id of element: {:type=>:html, :tag=>...}
+      #
+      def dom_id *args
+
+        use_default = false
+
+        case
+        when args.empty?
+          e = tag!
+          # do nothing else
+
+        when args.size == 1 && args.first == :default
+          e = tag!
+          use_default = true
+
+        when args.size == 1 && args.first.is_a?(::Hash) && args.first[:type]==:html
+          e = args.first
+
+        else
+          fail "Unknown args: #{args.inspect}"
+        end
+
+        id = e[:attrs][:id]
+        return id if id
+        return nil unless use_default
+
+        e[:default_id] ||= begin
+                             key = e[:tag]
+                             @default_ids[key] ||= -1
+                             @default_ids[key] += 1
+                           end
+      end # === def dom_id
+
+      #
+      # Examples
+      #    selector_id   -> a series of ids and tags to be used as a JS selector
+      #                     Example:
+      #                        #id tag tag
+      #                        tag tag
+      #
+      #
+      def selector_id
+        i        = tag![:tag_index]
+        id_given = false
+        classes  = []
+
+        while !id_given && i && i > -1
+          e         = @tag_arr[i]
+          id        = dom_id e
+          (id_given = true) if id
+
+          if e[:tag] == :body && !classes.empty?
+            # do nothing because
+            # we do not want 'body tag.class tag.class'
+          else
+            case
+            when id
+              classes << "##{id}"
+            else
+              classes << e[:tag]
+            end # === case
+          end # === if
+
+          i = e[:parent_index]
+        end
+
+        return 'body' if classes.empty?
+        classes.join SPACE
+      end
+
+      #
+      # Examples
+      #    css_id             -> current css id of element.
+      #                          It uses the first class, if any, found.
+      #                          #id.class     -> if #id and first class found.
+      #                          #id           -> if class is missing and id given.
+      #                          #id tag.class -> if class given and ancestor has id.
+      #                          #id tag tag   -> if no class given and ancestor has id.
+      #                          tag tag tag   -> if no ancestor has class.
+      #
+      #    css_id :my_class   -> same as 'css_id()' except
+      #                          'my_class' overrides :class attribute of current
+      #                          element.
+      #
+      #
+      def css_id *args
+
+        str_class = nil
+
+        case args.size
+        when 0
+          fail "Not in a tag." unless tag!
+          str_class = @css_id_override
+        when 1
+          str_class = args.first
+        else
+          fail "Unknown args: #{args.inspect}"
+        end
+
+        i        = tag![:tag_index]
+        id_given = false
+        classes  = []
+
+        while !id_given && i && i > -1
+          e           = @tag_arr[i]
+          id          = dom_id e
+          first_class = e[:attrs][:class].first
+
+          if id
+            id_given = true
+            if str_class
+              classes.unshift(
+                str_class.is_a?(::Symbol) ?
+                "##{id}.#{str_class}" :
+                "##{id}#{str_class}"
+              )
+            else
+              classes.unshift "##{id}"
+            end
+
+          else # no id given
+            if str_class
+              classes.unshift(
+                str_class.is_a?(::Symbol) ?
+                "#{e[:tag]}.#{str_class}" :
+                "#{e[:tag]}#{str_class}"
+              )
+            elsif first_class
+              classes.unshift "#{e[:tag]}.#{first_class}"
+            else
+              if e[:tag] != :body || (classes.empty?)
+                classes.unshift "#{e[:tag]}"
+              end
+            end # if first_class
+
+          end # if id
+
+          i = e[:parent_index]
+          break if i == @body[:tag_index] && !classes.empty?
+        end
+
+        classes.join SPACE
+      end
+
+    end # === module OLD
+  end # === module TO
+end # === class WWW_App
+
+
+
+__END__
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+:HEAD
+</head>
+:BODY
+</html>