mullet 0.0.0 → 0.0.1

data/lib/mullet/html/layout.rb

@@ -0,0 +1,48 @@
+require 'mullet/html/page_builder'
+require 'nokogiri'
+
+module Mullet; module HTML
+
+  # Extracts content from an HTML page and renders it in a layout.  The layout
+  # is a template given these variables:
+  #
+  # `title`
+  # :   content of the `title` element from the page
+  # `body`
+  # :   content of the `body` element from the page
+  #
+  # The `body` variable typically contains HTML markup, so the layout must
+  # use the `data-escape-xml="false"` command to prevent markup characters
+  # being escaped when rendering the variable.
+  class Layout
+
+    # Constructor
+    #
+    # @param [Template] template
+    #           layout using the template
+    def initialize(template)
+      @template = template
+    end
+
+    # Renders page data in a layout.
+    #
+    # @param [String] page_html
+    #           content from this HTML page will be rendered in the layout
+    # @param [#<<] output
+    #           where to write rendered output
+    def execute(page_html, output)
+      page = parse_page(page_html)
+      @template.execute(page, output)
+    end
+
+    private
+
+    def parse_page(page_html)
+      handler = PageBuilder.new()
+      parser = Nokogiri::HTML::SAX::Parser.new(handler)
+      parser.parse(page_html)
+      return handler.page
+    end
+  end
+
+end; end

data/lib/mullet/html/message.rb

@@ -0,0 +1,55 @@
+require 'i18n'
+require 'mullet/html/attribute_command'
+
+module Mullet; module HTML
+
+  # Holds the resource key and variable names that need to be resolved to
+  # format a localized message.
+  class Message
+    ARGUMENT_SEPARATOR = ','
+
+    # Constructor
+    #
+    # @param [String] message_arguments
+    #           message key and arguments string
+    def initialize(message_arguments)
+      arguments = message_arguments.split(ARGUMENT_SEPARATOR)
+      if arguments.empty?()
+        raise TemplateException.new(
+            "incorrect syntax in message #{message_arguments}")
+      end
+
+      @message_key = arguments.shift().strip()
+      if @message_key.empty?()
+        raise TemplateException.new(
+            "empty message key in message #{message_arguments}")
+      end
+
+      @argument_keys = []
+      arguments.each do |argument_key|
+        argument_key = argument_key.strip()
+        if argument_key.empty?()
+          raise TemplateException.new(
+              "empty argument key in message #{message_arguments}")
+        end
+        @argument_keys << argument_key.to_sym()
+      end
+    end
+
+    # Formats localized message.
+    #
+    # @param [RenderContext] render_context
+    #           render context
+    # @return localized message
+    def translate(render_context)
+      arguments = Hash.new()
+      @argument_keys.each do |argument_key|
+        arguments.store(
+            argument_key, render_context.get_display_value(argument_key))
+      end
+
+      return I18n.translate(@message_key, arguments)
+    end
+  end
+
+end; end

data/lib/mullet/html/message_attribute_command.rb

@@ -0,0 +1,30 @@
+require 'mullet/html/attribute_command'
+
+module Mullet; module HTML
+
+  # Operation to set attribute value from translation.
+  class MessageAttributeCommand
+    include AttributeCommand
+
+    # Constructor
+    #
+    # @param [Symbol] attribute_name
+    #           name of attribute this command sets
+    # @param [Message] message
+    #           message to format to get attribute value
+    def initialize(attribute_name, message)
+      super(attribute_name)
+      @message = message
+    end
+
+    # Gets attribute value by formatting localized message.
+    #
+    # @param [RenderContext] render_context
+    #           render context
+    # @return attribute value
+    def get_value(render_context)
+      return @message.translate(render_context)
+    end
+  end
+
+end; end

data/lib/mullet/html/model_attribute_command.rb

@@ -0,0 +1,30 @@
+require 'mullet/html/attribute_command'
+
+module Mullet; module HTML
+
+  # Operation to set attribute value from model.
+  class ModelAttributeCommand
+    include AttributeCommand
+
+    # Constructor
+    #
+    # @param [Symbol] attribute_name
+    #           name of attribute this command sets
+    # @param [Symbole] variable_name
+    #           variable name to lookup to get value
+    def initialize(attribute_name, variable_name)
+      super(attribute_name)
+      @variable_name = variable_name
+    end
+
+    # Gets attribute value by looking up variable name.
+    #
+    # @param [RenderContext] render_context
+    #           render context
+    # @return attribute value
+    def get_value(render_context)
+      return render_context.get_variable_value(@variable_name)
+    end
+  end
+
+end; end

data/lib/mullet/html/page_builder.rb

@@ -0,0 +1,152 @@
+require 'mullet/html/attributes'
+require 'mullet/html/command'
+require 'mullet/html/element'
+require 'mullet/html/element_renderer'
+require 'mullet/html/for_element_renderer'
+require 'mullet/html/if_element_renderer'
+require 'mullet/html/parser/default_handler'
+require 'mullet/html/parser/simple_parser'
+require 'mullet/html/remove_mode'
+require 'mullet/html/static_text_renderer'
+require 'mullet/html/template'
+require 'mullet/html/unless_element_renderer'
+require 'mullet/template_error'
+require 'set'
+
+module Mullet; module HTML
+
+  # Handles SAX events to extract content from an HTML page.
+  class PageBuilder < Parser::DefaultHandler
+
+    HEAD = 'head'
+    TITLE = 'title'
+    BODY = 'body'
+    START_CDATA = '<![CDATA['
+    END_CDATA = ']]>'
+
+    # TODO: Write an alternative implementation where we don't have to know
+    # which HTML elements have an empty content model.
+    EMPTY_CONTENT_ELEMENTS = Set[
+        'br',
+        'hr',
+        'img',
+        'input']
+
+    attr_reader :page
+
+    def start_document()
+      # number of open head elements
+      @head_count = 0
+
+      # Count of nested open elements where this handler is extracting their
+      # inner HTML.
+      @inner_depth = 0
+    
+      @page = Hash.new()
+    end
+
+    def start_element(name, attributes)
+      if name == HEAD
+        @head_count += 1
+      end
+
+      if extracting_inner_html?()
+        @inner_depth += 1
+        render_start_tag(name, attributes)
+        return
+      end
+
+      if @head_count > 0 && name == TITLE
+        start_extracting_inner_html()
+        return
+      end
+
+      if name == BODY
+        start_extracting_inner_html()
+      end
+    end
+
+    def end_element(name)
+      if name == HEAD
+        @head_count -= 1
+      end
+
+      if extracting_inner_html?()
+        @inner_depth -= 1
+        if extracting_inner_html?() && !EMPTY_CONTENT_ELEMENTS.include?(name)
+          render_end_tag(name)
+        end
+ 
+      end
+
+      if @head_count > 0 && name == TITLE
+        @page.store(:title, @inner_html)
+        return
+      end
+
+      if name == BODY
+        @page.store(:body, @inner_html)
+      end
+    end
+
+    def characters(data)
+      if extracting_inner_html?()
+        append(data)
+      end
+    end
+
+    def cdata_block(data)
+      if extracting_inner_html?()
+        append(data)
+      end
+    end
+
+    def comment(data)
+      if extracting_inner_html?()
+        append("<!--#{data}-->")
+      end
+    end
+
+    def processing_instruction(data)
+      if extracting_inner_html?()
+        append("<?#{data}?>")
+      end
+    end
+
+    private
+
+    def extracting_inner_html?()
+      return @inner_depth > 0
+    end
+
+    def start_extracting_inner_html()
+      @inner_depth = 1
+      @inner_html = ''
+    end
+
+    def append(data)
+      @inner_html << data
+    end
+
+    def escape_quote(value)
+      return value.include?('"') ? value.gsub(/"/, '&#34;') : value
+    end
+
+    def render_start_tag(tag_name, attributes)
+      append("<#{tag_name}")
+
+      attributes.each do |attribute|
+        qualified_name =
+            [attribute.prefix, attribute.localname].compact().join(':')
+        append(%( #{qualified_name}="#{escape_quote(attribute.value)}"))
+      end
+
+      append('>')
+    end
+
+    def render_end_tag(name)
+      append("</#{name}>")
+    end
+  end
+
+end; end

data/lib/mullet/html/parser/attribute.rb

@@ -0,0 +1,8 @@
+require 'nokogiri'
+
+module Mullet; module HTML; module Parser
+
+  class Attribute < Nokogiri::XML::SAX::Parser::Attribute
+  end
+
+end; end; end