mullet 0.0.0 → 0.0.1

data/lib/mullet/html/remove_mode.rb

@@ -0,0 +1,30 @@
+require 'mullet/template_error'
+
+module Mullet; module HTML
+
+  # Specifies what to remove.
+  class RemoveMode
+    # remove tag, and preserve children of element
+    TAG = RemoveMode.new()
+
+    # preserve tag, and remove children of element
+    CONTENT = RemoveMode.new()
+
+    # remove tag and children of element
+    ELEMENT = RemoveMode.new()
+    
+    def self.value_of(argument)
+      string = argument.downcase()
+      if string == 'element'
+        return ELEMENT
+      elsif string == 'tag'
+        return TAG
+      elsif string == 'content'
+        return CONTENT
+      else
+        raise TemplateError.new("invalid remove argument '%{argument}'")
+      end
+    end
+  end
+
+end; end

data/lib/mullet/html/static_text_renderer.rb

@@ -0,0 +1,20 @@
+module Mullet; module HTML
+
+  # Renders static markup and text. May end with an unclosed start tag under
+  # the assumption a subsequent static text fragment closes the tag.
+  class StaticTextRenderer
+
+    # Constructor
+    #
+    # @param [String] text
+    #           rendered tags and text
+    def initialize(text)
+      @text = text
+    end
+
+    def render(render_context)
+      render_context << @text
+    end
+  end
+
+end; end

data/lib/mullet/html/template.rb

@@ -0,0 +1,44 @@
+require 'mullet/container'
+require 'mullet/render_context'
+
+module Mullet; module HTML
+
+  # Template containing static text and dynamically generated content.
+  class Template
+    include Container
+
+    RETURN_EMPTY_STRING = Proc.new { '' }
+
+    def initialize()
+      super
+      @on_missing = RETURN_EMPTY_STRING
+      @on_nil = RETURN_EMPTY_STRING
+    end
+
+    def on_missing(strategy)
+      @on_missing = strategy
+      return self
+    end
+
+    def on_nil(strategy)
+      @on_nil = strategy
+      return self
+    end
+
+    def render(render_context)
+      render_children(render_context)
+    end
+
+    # Renders the template.
+    #
+    # @param [Object] data
+    #           provides data to render
+    # @param [#<<] output
+    #           where to write rendered output
+    def execute(data, output)
+      render_context = RenderContext.new(data, @on_missing, @on_nil, output)
+      render(render_context)
+    end
+  end
+
+end; end

data/lib/mullet/html/template_builder.rb

@@ -1,46 +1,65 @@
-require 'nokogiri'
+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 build a template.
-  class TemplateBuilder < Nokogiri::XML::SAX::Document
+  class TemplateBuilder < Parser::DefaultHandler
     include Command
 
-    XMLNS_ATTRIBUTE_PREFIX = "xmlns:"
-    COMMANDS = [
-        ATTRIBUTE,
-        ATTRIBUTE_MESSAGE,
-        CONTENT,
+    COMMANDS = Set[
+        ACTION,
+        ALT,
+        ALT_MESSAGE,
+        ATTR,
+        ATTR_MESSAGE,
         ESCAPE_XML,
         FOR,
+        HREF,
         IF,
         INCLUDE,
+        REMOVE,
+        SRC,
         TEXT,
         TEXT_MESSAGE,
-        UNLESS].to_set
-    START_CDATA = "<![CDATA["
-    END_CDATA = "]]>"
+        TITLE,
+        TITLE_MESSAGE,
+        UNLESS,
+        VALUE,
+        VALUE_MESSAGE]
+    START_CDATA = '<![CDATA['
+    END_CDATA = ']]>'
 
-    @loader = nil
+    attr_reader :template
 
-    # This is a stack of elements where this handler has seen the start tag and
-    # not yet seen the end tag.
-    @openElements = []
-
-    # stack of current containers to add renderers to
-    @containers = []
-    
-    @staticText = ""
-    @template = nil
-    
     # Constructor
     #
     # @param [TemplateLoader] loader
     #           template loader to use to load included template files
     def initialize(loader)
       @loader = loader
+
+      # Stack of elements where this handler has seen the start tag and not yet
+      # seen the end tag.
+      @open_elements = []
+
+      # stack of current containers to add renderers to
+      @containers = []
+    
+      @static_text = ''
+      @template = nil
     end
 
     # Adds renderer to current container.
@@ -48,7 +67,7 @@ module Mullet; module HTML
     # @param [#render] renderer
     #           renderer to add
     def add_child(renderer)
-      @containers.last.add_child(renderer)
+      @containers.last().add_child(renderer)
     end
 
     # Deletes renderer from current container.
@@ -56,7 +75,7 @@ module Mullet; module HTML
     # @param [#render] renderer
     #           renderer to delete
     def delete_child(renderer)
-      @containers.last.delete_child(renderer)
+      @containers.last().delete_child(renderer)
     end
 
     # Partitions the attributes into ordinary and command attributes.
@@ -65,77 +84,203 @@ module Mullet; module HTML
     #           input attributes
     # @param [Hash] ns
     #           hash of namespace prefix to uri mappings
-    # @param [#store] ordinaryAttributes
+    # @param [#store] ordinary_attributes
     #           hash will receive name to value mappings for ordinary attributes
-    # @param [#store] commandAttributes
+    # @param [#store] command_attributes
     #           hash will receive name to value mappings for command attributes
     # @return [Boolean] true if any command attribute found
-    def find_commands(attributes, ns, ordinaryAttributes, commandAttributes)
-      foundCommand = false
+    def find_commands(attributes, ns, ordinary_attributes, command_attributes)
+      found_command = false
       attributes.each do |attr|
-        if attr.uri == NAMESPACE_URI
-          commandName = attr.localname
-          if !COMMANDS.contains(commandName)
-            raise TemplateException("invalid command '#{commandName}'")
+        if attr.localname.start_with?(DATA_PREFIX)
+          command_name = attr.localname.slice(DATA_PREFIX.length()..-1)
+          if COMMANDS.include?(command_name)
+            command_attributes.store(command_name, attr.value)
+            found_command = true
+          end
+        elsif attr.uri == NAMESPACE_URI || attr.prefix == NAMESPACE_PREFIX
+          command_name = attr.localname
+          if !COMMANDS.include?(command_name)
+            raise TemplateError("invalid command '#{command_name}'")
           end
-          commandAttributes.store(commandName, attr.value)
-          foundCommand = true
+          command_attributes.store(command_name, attr.value)
+          found_command = true
         else
-          attributeName = [attr.prefix, attr.localname].compact.join(':')
-          ordinaryAttributes.store(attributeName, attr.value)
+          attribute_name = [attr.prefix, attr.localname].compact().join(':')
+          ordinary_attributes.store(attribute_name, attr.value)
         end
       end
 
       ns.each do |prefix, uri|
         if uri != NAMESPACE_URI
-          attributeName = ['xmlns', prefix].compact.join(':')
-          ordinaryAttributes.store(attributeName, uri)
+          attribute_name = ['xmlns', prefix].compact().join(':')
+          ordinary_attributes.store(attribute_name, uri)
         end
       end
 
-      return foundCommand
+      return found_command
     end
 
-    def render_start_tag(name, attributes, prefix, uri, namespaceDecls)
-      tag = "<"
-      if prefix
-        tag << prefix << ":"
+    def append_static_text(data)
+      @static_text << data
+    end
+
+    def end_static_text()
+      if !@static_text.empty?()
+        add_child(StaticTextRenderer.new(@static_text))
+        @static_text = ''
+      end
+    end
+
+    # Marks the most deeply nested open element as having content.
+    def set_has_content()
+      if !@open_elements.empty?()
+        @open_elements.last().has_content = true
+      end
+    end
+
+    def start_document()
+      @template = Template.new()
+      @containers.push(@template)
+    end
+
+    def end_document()
+      end_static_text()
+    end
+
+    def doctype(name, public_id, system_id)
+      text = "<!DOCTYPE #{name}"
+
+      if public_id
+        text << %( PUBLIC "#{public_id}")
+      end
+
+      if system_id
+        text << %( "#{system_id}")
+      end
+
+      text << '>'
+      append_static_text(text)
+    end
+
+    def create_element_renderer(element, command_attributes)
+      renderer = nil
+
+      variable_name = command_attributes.fetch(IF, nil)
+      if variable_name != nil
+        renderer = IfElementRenderer.new(element, variable_name)
       end
-      tag << name
 
-      attributes.each do |attribute|
-        tag << " "
-        if attribute.prefix
-          tag << attribute.prefix << ":"
+      if renderer == nil
+        variable_name = command_attributes.fetch(UNLESS, nil)
+        if variable_name != nil
+          renderer = UnlessElementRenderer.new(element, variable_name)
         end
-        tag = attribute.localname << '="' << attribute.value << '"'
       end
 
-      namespaceDecls.each do |namespaceDecl|
-        uri = namespaceDecl[1] 
-        if uri != TEMPLATE_NAMESPACE_URI
-          tag << " xmlns:" << namespaceDecl[0] << '="' << uri << '"'
+      if renderer == nil
+        variable_name = command_attributes.fetch(FOR, nil)
+        if variable_name != nil
+          renderer = ForElementRenderer.new(element, variable_name)
         end
       end
 
-      tag << ">"
-      return tag
+      if renderer == nil
+        renderer = ElementRenderer.new(element)
+      end
+
+      renderer.configure_commands(command_attributes, @loader)
+      return renderer
     end
 
     def start_element_namespace(name, attributes, prefix, uri, ns)
-      puts "start element #{name} #{attributes} #{prefix} #{uri} #{ns}"
-      templateAttributes = attributes.select do |attribute|
-        attribute.uri == TEMPLATE_NAMESPACE_URI
-      end
-      if templateAttributes.empty?
-        puts render_start_tag(name, attributes, prefix, uri, ns)
+      set_has_content()
+
+      ordinary_attributes = Attributes.new()
+      command_attributes = Attributes.new()
+      found_command = find_commands(
+          attributes, ns, ordinary_attributes, command_attributes)
+
+      qualified_name = [prefix, name].compact().join(':')
+      element = Element.new(qualified_name, ordinary_attributes)
+      @open_elements.push(element)
+
+      if found_command
+        end_static_text()
+
+        element.has_command = true
+        renderer = create_element_renderer(element, command_attributes)
+        add_child(renderer)
+
+        @containers.push(renderer)
       else
-        puts "attributes #{templateAttributes}"
+        append_static_text(element.render_start_tag(element.attributes))
       end
     end
 
-    def end_document
-      puts "the document has ended"
+    def configure_remove_command(element, renderer)
+      case renderer.remove_mode
+      when RemoveMode::TAG
+        if !renderer.has_command && !renderer.has_dynamic_content
+          # Discard tag, but preserve the children.
+          delete_child(renderer)
+          renderer.children.each do |child|
+            add_child(child)
+          end
+        end
+      when RemoveMode::CONTENT
+        if !renderer.has_command
+          # Discard children. Statically render the tag.
+          delete_child(renderer)
+
+          append_static_text(element.render_start_tag(element.attributes))
+          append_static_text(element.render_end_tag())
+        end
+      when RemoveMode::ELEMENT
+        # Discard element and all its content.
+        delete_child(renderer)
+      end
+    end
+
+    def end_element_namespace(name, prefix, uri)
+      element = @open_elements.pop()
+      if element.has_command
+        end_static_text()
+
+        renderer = @containers.pop()
+        if renderer.has_dynamic_content
+          # Discard children because the content will be replaced at render
+          # time.
+          renderer.clear_children()
+        end
+
+        configure_remove_command(element, renderer)
+      elsif uri != Parser::SimpleParser::IMPLICIT_END_TAG_NS_URI
+        append_static_text(element.render_end_tag())
+      end
+    end
+
+    def characters(data)
+      set_has_content()
+      append_static_text(data)
+    end
+
+    def cdata_block(data)
+      append_static_text(START_CDATA)
+      characters(data)
+      append_static_text(END_CDATA)
+    end
+
+    def comment(data)
+      append_static_text('<!--')
+      characters(data)
+      append_static_text('-->')
+    end
+
+    def processing_instruction(data)
+      append_static_text('<?')
+      characters(data)
+      append_static_text('?>')
     end
   end
 

data/lib/mullet/html/template_loader.rb

@@ -1,55 +1,93 @@
-require 'nokogiri'
+require 'mullet/html/template'
+require 'mullet/html/template_parser'
 
-module Mullet
+module Mullet; module HTML
 
-class TemplateDocument < Nokogiri::XML::SAX::Document
-  TEMPLATE_NAMESPACE_URI = "http://pukkaone.github.com/mullet/1"
+  # Loads templates from files, and caches them for fast retrieval of already
+  # loaded templates.
+  #
+  # By default, templates render an empty string when a variable is not found
+  # or its value is null. Call the `on_missing` and `on_nil` methods to
+  # configure how templates loaded by this loader should handle missing and nil
+  # values respectively.
+  class TemplateLoader
+    
+    attr_accessor :template_path
 
-  def render_start_tag(name, attributes, prefix, uri, namespaceDecls)
-    tag = "<"
-    if prefix
-      tag << prefix << ":"
+    # Constructor
+    #
+    # @param [String] template_path
+    #           name of directory to load templates from
+    def initialize(template_path)
+      @template_path = template_path
+      @template_cache = Hash.new()
+      @parser = TemplateParser.new(self)
+      @on_missing = Template::RETURN_EMPTY_STRING
+      @on_nil = Template::RETURN_EMPTY_STRING
+    end
+    
+    # Sets block to execute on attempt to render a variable that was not found.
+    #
+    # @param [Proc] strategy
+    #           The value returned from block will be rendered.
+    # @return [TemplateLoader] this object to allow method call chaining
+    def on_missing(strategy)
+      @on_missing = strategy
+      return self
     end
-    tag << name
 
-    attributes.each do |attribute|
-      tag << " "
-      if attribute.prefix
-        tag << attribute.prefix << ":"
-      end
-      tag = attribute.localname << '="' << attribute.value << '"'
+    # Sets block to execute on attempt to render a nil value.
+    #
+    # @param [Proc] strategy
+    #           The value returned from block will be rendered.
+    # @return [TemplateLoader] this object to allow method call chaining
+    def on_nil(strategy)
+      @on_nil = strategy
+      return self
     end
 
-    namespaceDecls.each do |namespaceDecl|
-      uri = namespaceDecl[1] 
-      if uri != TEMPLATE_NAMESPACE_URI
-        tag << " xmlns:" << namespaceDecl[0] << '="' << uri << '"'
+    # Loads named template.
+    #
+    # @param [String] uri
+    #           file name optionally followed by `#`_id_
+    def load(uri)
+      id = nil
+      hash_index = uri.index('#')
+      if hash_index
+        id = uri[(hash_index + 1)..-1]
+        uri = uri[0...hash_index]
       end
+
+      return load_file(uri, id)
     end
 
-    tag << ">"
-    return tag
-  end
+    private
 
-  def start_element_namespace(name, attributes, prefix, uri, ns)
-    puts "start element #{name} #{attributes} #{prefix} #{uri} #{ns}"
-    templateAttributes = attributes.select do |attribute|
-      attribute.uri == TEMPLATE_NAMESPACE_URI
+    def get_cache_key(file_name, id)
+      cache_key = File.join(@template_path, file_name)
+      if id != nil
+        cache_key << '#' << id
+      end
+      return cache_key
     end
-    if templateAttributes.empty?
-      puts render_start_tag(name, attributes, prefix, uri, ns)
-    else
-      puts "attributes #{templateAttributes}"
+
+    def parse_file(file_name, id)
+      template_file = File.join(@template_path, file_name)
+      template = @parser.parse_file(template_file, id)
+
+      template.on_missing(@on_missing).on_nil(@on_nil)
+      return template
     end
-  end
 
-  def end_document
-    puts "the document has ended"
+    def load_file(file_name, id)
+      cache_key = get_cache_key(file_name, id)
+      template = @template_cache.fetch(cache_key, nil)
+      if template == nil
+        template = parse_file(file_name, id)
+        @template_cache.store(cache_key, template)
+      end
+      return template
+    end
   end
-end
 
-parser = Nokogiri::HTML::SAX::Parser.new(TemplateDocument.new)
-f = File.open("login.html")
-parser.parse(f)
-f.close
-end
+end; end

data/lib/mullet/html/template_parser.rb

@@ -0,0 +1,48 @@
+require 'mullet/html/filtered_element_handler'
+require 'mullet/html/parser/simple_parser'
+require 'mullet/html/template_builder'
+
+module Mullet; module HTML
+
+  class TemplateParser
+
+    def initialize(loader)
+      @loader = loader
+    end
+
+    # Parses template from string.
+    #
+    # @param [String] source
+    #           string to parse
+    # @return [Template] template
+    def parse(source)
+      template_builder = TemplateBuilder.new(@loader)
+      parser = Parser::SimpleParser.new(template_builder)
+      parser.parse(source)
+      return template_builder.template
+    end
+
+    # Parses template from file.
+    #
+    # @param [String] file_name
+    #           name of file containing template
+    # @param [String] id
+    #           If `nil`, then the template is the entire file, otherwise the
+    #           template is the content of the element having an `id` attribute
+    #           value equal to this argument.
+    # @return [Template] template
+    def parse_file(file_name, id)
+      template_builder = TemplateBuilder.new(@loader)
+      handler = (id == nil) ?
+          template_builder : FilteredElementHandler.new(template_builder, id)
+
+      parser = Parser::SimpleParser.new(handler)
+      File.open(file_name) do |file|
+        parser.parse(file)
+      end
+
+      return template_builder.template
+    end
+  end
+
+end; end

data/lib/mullet/html/unless_element_renderer.rb

@@ -0,0 +1,24 @@
+require 'mullet/html/if_element_renderer'
+
+module Mullet; module HTML
+
+  # Renders an element if variable is false.
+  class UnlessElementRenderer < IfElementRenderer
+
+    # Constructor
+    #
+    # @param [Element] element
+    #           element to render
+    # @param [String] variable_name
+    #           name of variable containing condition
+    def initialize(element, variable_name)
+      super(element, variable_name)
+      @variable_name = variable_name.to_sym()
+    end
+
+    def should_render_element(render_context)
+      return !super
+    end
+  end
+
+end; end

data/lib/mullet/model.rb

@@ -1,10 +1,7 @@
 module Mullet
 
-  # A model responds to the method `fetch` taking a variable name argument and
-  # returning the variable value.  If the variable name is not found, it
-  # returns the value `NOT_FOUND` instead of raising an exception.  A model
-  # class must include this module because the implementation calls
-  # `is_a?(Model)` to determine if an object satisfies the concept of a model.
+  # A model responds to the method `get_variable_value` taking a variable name
+  # argument and returning the variable value.  
   module Model
 
     # special value indicating variable name was not found