mullet 0.0.0 → 0.0.1

data/lib/mullet/container.rb

@@ -8,24 +8,28 @@ module Mullet
     end
 
     def add_child(child)
-      @children << child
+      @children.push(child)
     end
 
     def delete_child(child)
       @children.delete(child);
     end
 
+    def children()
+      return @children
+    end
+
     def clear_children()
       @children.clear()
     end
 
     # Renders children in order they were added.
     # 
-    # @param [RenderContext] renderContext
+    # @param [RenderContext] render_context
     #           render context
-    def render_children(renderContext)
+    def render_children(render_context)
       @children.each do |child|
-        child.render(renderContext)
+        child.render(render_context)
       end
     end
   end

data/lib/mullet/default_model.rb

@@ -22,27 +22,27 @@ module Mullet
       @data = data
     end
 
-    def fetch_impl(key)
-      if key == :this
+    def fetch_impl(name)
+      if name == :this
         return @data
       end
 
       # Is the variable name a key in a Hash?
       if @data.respond_to?(:fetch)
         # Call the block if the key is not found.
-        return @data.fetch(key) {|k| @data.fetch(k.to_s(), NOT_FOUND) }
+        return @data.fetch(name) {|k| @data.fetch(k.to_s(), NOT_FOUND) }
       end
 
       # Does the variable name match a method name in the object?
-      if @data.respond_to?(key)
-        method = @data.method(key)
+      if @data.respond_to?(name)
+        method = @data.method(name)
         if method.arity == 0
           return method.call()
         end
       end
 
       # Does the variable name match an instance variable name in the object?
-      variable = :"@#{key}"
+      variable = :"@#{name}"
       if @data.instance_variable_defined?(variable)
         return @data.instance_variable_get(variable)
       end
@@ -52,11 +52,11 @@ module Mullet
 
     # Resolves variable name to value.
     # 
-    # @param [Symbol] key
+    # @param [Symbol] name
     #           variable name
     # @return variable value
-    def fetch(key)
-      value = fetch_impl(key)
+    def get_variable_value(name)
+      value = fetch_impl(name)
       if value.is_a?(Proc)
         value = value.call()
       end

data/lib/mullet/default_nested_model.rb

@@ -18,18 +18,18 @@ module Mullet
 
     # Resolves variable name to value.
     # 
-    # @param [Symbol] key
+    # @param [Symbol] name
     #           variable name
     # @return variable value
-    def fetch(key)
+    def get_variable_value(name)
       @scopes.reverse_each do |scope|
-        value = scope.fetch(key)
-        if value != Model::NOT_FOUND
+        value = scope.get_variable_value(name)
+        if value != NOT_FOUND
           return value
         end
       end
 
-      return Model::NOT_FOUND
+      return NOT_FOUND
     end
 
     # Adds a nested scope to search in subsequent lookups.
@@ -37,7 +37,8 @@ module Mullet
     # @param data
     #           data object
     def push_scope(data)
-      @scopes.push(data.is_a?(Model) ? data : DefaultModel.new(data))
+      @scopes.push(
+          data.respond_to?(:get_variable_value) ? data : DefaultModel.new(data))
     end
 
     # Removes innermost nested scope.

data/lib/mullet/html/attribute_command.rb

@@ -1,6 +1,10 @@
-module Mullet
+require 'mullet/model'
 
-  # Operation to set attribute value.
+module Mullet; module HTML
+
+  # Operation to set attribute value.  Classes including this module are
+  # expected to respond to the get_value method returning the attribute value
+  # to set.
   module AttributeCommand
 
     # Constructor
@@ -11,7 +15,7 @@ module Mullet
       @attribute_name = attribute_name
     end
 
-    # Sets attribute in the _attributecommand.
+    # Sets attribute in the _attributes_ collection.
     #
     # @param [RenderContext] render_context
     #           render context
@@ -29,4 +33,4 @@ module Mullet
     end
   end
 
-end
+end; end

data/lib/mullet/html/attributes.rb

@@ -0,0 +1,22 @@
+module Mullet; module HTML
+
+  # Maps attribute names to values.  Also renders attributes to HTML.
+  class Attributes < Hash
+
+    def escape_quote(value)
+      return value.include?('"') ? value.gsub(/"/, '&#34;') : value
+    end
+
+    # Renders attributes to HTML syntax.
+    #
+    # @return rendered HTML
+    def render()
+      output = ''
+      each do |key, value|
+        output << %( #{key}="#{escape_quote(value)}")
+      end
+      return output
+    end
+  end
+
+end; end

data/lib/mullet/html/command.rb

@@ -1,8 +1,9 @@
-module Mullet
+module Mullet; module HTML
 
   # Recognized template commands
   module Command
-    PREFIX = 'mullet:'
+    DATA_PREFIX = 'data-'
+    NAMESPACE_PREFIX = 'mullet'
     NAMESPACE_URI = 'http://pukkaone.github.com/mullet/1'
 
     ACTION = 'action'
@@ -26,4 +27,4 @@ module Mullet
     VALUE_MESSAGE = 'value-message'
   end
 
-end
+end; end

data/lib/mullet/html/command_element_renderer.rb

@@ -0,0 +1,19 @@
+module Mullet; module HTML
+
+  # Answers true when asked if it has any command.
+  class CommandElementRenderer < ElementRenderer
+
+    # Constructor
+    #
+    # @param [Element] element
+    #           element to render
+    def initialize(element)
+      super(element)
+    end
+
+    def has_command()
+      return true
+    end
+  end
+
+end; end

data/lib/mullet/html/element.rb

@@ -0,0 +1,41 @@
+module Mullet; module HTML
+
+  # HTML element
+  class Element
+
+    # attributes from template
+    attr_reader :attributes
+
+    # true if element has any child element or text content
+    attr_accessor :has_content
+
+    # true if element has any template command
+    attr_accessor :has_command
+
+    # Constructor
+    #
+    # @param [String] qualified_name
+    #           tag name with namespace prefix
+    # @param [Attributes] attributes
+    #           attributes from template
+    def initialize(qualified_name, attributes)
+      @name = qualified_name
+      @attributes = attributes
+      @has_content = false
+      @has_command = false
+    end
+
+    # Renders start tag
+    #
+    # @param [Attributes] attributes
+    #           attributes to render
+    def render_start_tag(attributes)
+      return "<#{@name}#{attributes.render()}>"
+    end
+
+    def render_end_tag()
+      return "</#{@name}>"
+    end
+  end
+
+end; end

data/lib/mullet/html/element_renderer.rb

@@ -0,0 +1,261 @@
+require 'mullet/container'
+require 'mullet/template_error'
+require 'mullet/html/command'
+require 'mullet/html/message'
+require 'mullet/html/message_attribute_command'
+require 'mullet/html/model_attribute_command'
+
+module Mullet; module HTML
+
+  # Renders an HTML element.
+  class ElementRenderer
+    include Container
+
+    ATTRIBUTE_SEPARATOR = ';'
+    ATTRIBUTE_NAME_SEPARATOR = '='
+    ATTRIBUTE_SYNTAX_ERROR = "expected '%s' in '%s'"
+    ATTRIBUTE_NAME_MISSING_ERROR = "attribute name missing in '%s'"
+    CONVENIENT_ATTRIBUTE_COMMANDS = [
+        Command::ACTION,
+        Command::ALT,
+        Command::HREF,
+        Command::SRC,
+        Command::TITLE,
+        Command::VALUE ]
+
+    attr_reader :remove_mode
+
+    # Constructor
+    #
+    # @param [Element] element
+    #           element to render
+    def initialize(element)
+      super()
+
+      @element = element
+      @attribute_commands = []
+      @remove_mode = nil
+      @text_variable_name = nil
+      @text_message = nil
+      @template = nil
+      @escape_xml = nil
+    end
+
+    def add_attribute_command(attribute_name, variable_name)
+      @attribute_commands <<
+          ModelAttributeCommand.new(attribute_name, variable_name)
+    end
+
+    def add_attribute_commands(attribute_variable_pairs)
+      attribute_variable_pairs.split(ATTRIBUTE_SEPARATOR).each do |command_text|
+        command_parts = command_text.split(ATTRIBUTE_NAME_SEPARATOR, 2)
+        if command_parts.length() < 2
+          raise TemplateError.new(
+              ATTRIBUTE_SYNTAX_ERROR % [ATTRIBUTE_NAME_SEPARATOR, command_text])
+        end
+
+        attribute_name = command_parts[0].strip()
+        if attribute_name.empty?()
+          raise TemplateError.new(ATTRIBUTE_NAME_MISSING_ERROR % command_text)
+        end
+
+        variable_name = command_parts[1].strip()
+        if variable_name.empty?()
+          raise TemplateError.new("variable name missing in '#{command_text}'")
+        end
+
+        add_attribute_command(attribute_name, variable_name)
+      end
+    end
+
+    def configure_attribute_commands(command_attributes)
+      value = command_attributes.fetch(Command::ATTR, nil)
+      if value != nil
+        add_attribute_commands(value)
+      end
+
+      CONVENIENT_ATTRIBUTE_COMMANDS.each do |attribute_name|
+        value = command_attributes.fetch(attribute_name, nil)
+        if value != nil
+          add_attribute_command(attribute_name, value)
+        end
+      end
+
+      value = command_attributes.fetch(Command::REMOVE, nil)
+      if value != nil
+        value.strip!();
+        value.downcase!()
+        @remove_mode = RemoveMode.value_of(value)
+        if @remove_mode == nil
+          raise TemplateError.new("invalid remove argument '#{value}'")
+        end
+      end
+    end
+
+    def add_attribute_message_command(attribute_name, message_arguments)
+      @attribute_commands << MessageAttributeCommand.new(
+          attribute_name, Message.new(message_arguments))
+    end
+
+    def add_attribute_message_commands(attribute_message_pairs)
+      attribute_message_pairs.split(ATTRIBUTE_SEPARATOR).each do |command_text|
+        command_parts = command_text.split(ATTRIBUTE_NAME_SEPARATOR, 2)
+        if command_parts.length() < 2
+          raise TemplateError.new(
+              ATTRIBUTE_SYNTAX_ERROR % [ATTRIBUTE_NAME_SEPARATOR, command_text])
+        end
+
+        attribute_name = command_parts[0].strip()
+        if attribute_name.empty?()
+          raise TemplateError.new(ATTRIBUTE_NAME_MISSING_ERROR % command_text)
+        end
+
+        message_arguments = command_parts[1].strip()
+        if message_arguments.empty?()
+          raise TemplateError.new(
+              "message arguments missing in '#{command_text}'")
+        end
+
+        add_attribute_message_command(attribute_name, message_arguments)
+      end
+    end
+
+    def configure_attribute_message_commands(command_attributes)
+      value = command_attributes.fetch(Command::ALT_MESSAGE, nil)
+      if value != nil
+        add_attribute_message_command(Command::ALT, value)
+      end
+
+      value = command_attributes.fetch(Command::ATTR_MESSAGE, nil)
+      if value != nil
+        add_attribute_message_commands(value)
+      end
+
+      value = command_attributes.fetch(Command::TITLE_MESSAGE, nil)
+      if value != nil
+        add_attribute_message_command(Command::TITLE, value)
+      end
+
+      value = command_attributes.fetch(Command::VALUE_MESSAGE, nil)
+      if value != nil
+        add_attribute_message_command(Command::VALUE, value)
+      end
+    end
+
+    def configure_content(command_attributes, template_loader)
+      @text_variable_name = command_attributes.fetch(Command::TEXT, nil)
+      if @text_variable_name != nil
+        @text_variable_name = @text_variable_name.to_sym()
+        return
+      end
+
+      text_message_arguments =
+          command_attributes.fetch(Command::TEXT_MESSAGE, nil)
+      if text_message_arguments != nil
+        @text_message = Message.new(text_message_arguments)
+        return
+      end
+
+      uri = command_attributes.fetch(Command::INCLUDE, nil)
+      if uri != nil
+        @template = template_loader.load(uri)
+      end
+    end
+
+    def configure_commands(command_attributes, template_loader)
+      configure_attribute_commands(command_attributes)
+      configure_attribute_message_commands(command_attributes)
+
+      configure_content(command_attributes, template_loader)
+
+      escape_xml_value = command_attributes.fetch(Command::ESCAPE_XML, nil)
+      if escape_xml_value != nil
+        @escape_xml = escape_xml_value != 'false' 
+      end
+    end
+
+    # Checks if this renderer has a command.  If it has a command, then the
+    # template builder should not discard it.
+    def has_command()
+      return !@attribute_commands.empty?()
+    end
+
+    # Checks if the element content will be rendered by a command.
+    def has_dynamic_content()
+      return @text_variable_name != nil ||
+             @text_message != nil ||
+             @template != nil
+    end
+
+    def execute_attribute_commands(render_context)
+      if @attribute_commands.empty?()
+        return @element.attributes()
+      end
+
+      # Copy the original attributes.  The commands modify the copy to
+      # produce the attributes to render.
+      render_attributes = @element.attributes().dup()
+      @attribute_commands.each do |command|
+        command.execute(render_context, render_attributes)
+      end
+      return render_attributes
+    end
+
+    def should_render_tag()
+      return @remove_mode == nil || @remove_mode == RemoveMode::CONTENT
+    end
+
+    def render_start_tag(render_context)
+      if should_render_tag()
+        attributes = execute_attribute_commands(render_context)
+        render_context << @element.render_start_tag(attributes)
+      end
+    end
+
+    def render_end_tag(render_context)
+      if should_render_tag()
+        render_context << @element.render_end_tag()
+      end
+    end
+
+    def should_render_content()
+      return @remove_mode != RemoveMode::CONTENT
+    end
+
+    def render_content(render_context)
+      if should_render_content()
+        if @text_variable_name != nil
+          value = render_context.get_display_value(@text_variable_name)
+          text = render_context.escape_xml(value.to_s())
+          render_context << text
+        elsif @text_message != nil
+          text = @text_message.translate(render_context)
+          text = render_context.escape_xml(text)
+          render_context << text
+        elsif @template != nil
+          @template.render(render_context)
+        else
+          render_children(render_context)
+        end
+      end
+    end
+
+    def render(render_context)
+      # Process the command to change the escaping mode.
+      original_escape_xml_enabled = render_context.escape_xml_enabled()
+      if @escape_xml != nil
+        render_context.escape_xml_enabled = @escape_xml
+      end
+
+      render_start_tag(render_context)
+      render_content(render_context)
+      render_end_tag(render_context)
+
+      # Restore the original escaping mode.
+      if @escape_xml != nil
+        render_context.escape_xml_enabled = original_escape_xml_enabled
+      end
+    end
+  end
+
+end; end

data/lib/mullet/html/filtered_element_handler.rb

@@ -0,0 +1,87 @@
+require 'mullet/html/command'
+require 'mullet/template_error'
+require 'nokogiri'
+require 'set'
+
+module Mullet; module HTML
+
+  # Proxy for a SAX event handler that forwards events only while the
+  # parser is within an element identified by an `id` attribute.
+  class FilteredElementHandler < Nokogiri::XML::SAX::Document
+    ID = 'id'
+
+    # Constructor
+    #
+    # @param [Document] handler
+    #           event handler to forward events to
+    # @param [String] id
+    #           id attribute value
+    def initialize(handler, id)
+      @handler = handler
+      @id = id
+      @depth = 0
+      @found_id = false
+    end
+
+    def should_forward()
+      return @depth > 0
+    end
+
+    def start_document()
+      @handler.start_document()
+    end
+
+    def end_document()
+      @handler.end_document()
+
+      if !@found_id
+        raise TemplateError.new("element with attribute id='#{@id}' not found")
+      end
+    end
+
+    def start_element_namespace(name, attributes, prefix, uri, namespaces)
+      if should_forward()
+        @depth += 1
+        return @handler.start_element_namespace(
+            name, attributes, prefix, uri, namespaces)
+      end
+
+      value = attributes.each do |attr|
+        qualified_name = [attr.prefix, attr.localname].compact.join(':')
+        if qualified_name == ID && attr.value == @id
+          # Enable event forwarding.
+          @depth = 1
+          @found_id = true
+        end
+      end
+    end
+
+    def end_element_namespace(name, prefix, uri)
+      if should_forward()
+        @depth -= 1
+        if @depth > 0
+          @handler.end_element_namespace(name, prefix, uri)
+        end
+      end
+    end
+
+    def characters(data)
+      if should_forward()
+        @handler.characters(data)
+      end
+    end
+
+    def cdata_block(data)
+      if should_forward()
+        @handler.cdata_block(data)
+      end
+    end
+
+    def comment(data)
+      if should_forward()
+        @handler.comment(data)
+      end
+    end
+  end
+
+end; end

data/lib/mullet/html/for_element_renderer.rb

@@ -0,0 +1,47 @@
+require 'mullet/html/command_element_renderer'
+require 'mullet/model'
+
+module Mullet; module HTML
+
+  # Renders an element for each item in a collection.
+  class ForElementRenderer < CommandElementRenderer
+
+    # Constructor
+    #
+    # @param [Element] element
+    #           element to render
+    # @param [String] variable_name
+    #           name of variable containing collection
+    def initialize(element, variable_name)
+      super(element)
+      @variable_name = variable_name.to_sym()
+    end
+
+    alias :super_render :render
+
+    def render_nested_model(data, render_context)
+      render_context.push_scope(data)
+      super_render(render_context)
+      render_context.pop_scope()
+    end
+
+    def render(render_context)
+      value = render_context.get_variable_value(@variable_name)
+      if value == Model::NOT_FOUND || value == nil || value == false
+        return
+      end
+
+      if value.respond_to?(:empty?) && value.empty?()
+        return
+      end
+
+      if value.respond_to?(:each)
+        value.each {|item| render_nested_model(item, render_context) }
+        return
+      end
+
+      render_nested_model(value, render_context)
+    end
+  end
+
+end; end

data/lib/mullet/html/if_element_renderer.rb

@@ -0,0 +1,46 @@
+require 'mullet/html/command_element_renderer'
+require 'mullet/model'
+
+module Mullet; module HTML
+
+  # Renders an element if variable is true.
+  class IfElementRenderer < CommandElementRenderer
+
+    # 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.to_sym()
+    end
+
+    def should_render_element(render_context)
+      value = render_context.get_variable_value(@variable_name)
+      if value == Model::NOT_FOUND || value == nil
+        return false
+      end
+
+      if value.is_a?(FalseClass) || value.is_a?(TrueClass)
+        return value
+      end
+
+      if value.respond_to?(:empty?)
+        return !value.empty?()
+      end
+
+      return true
+    end
+
+    alias :super_render :render
+
+    def render(render_context)
+      if should_render_element(render_context)
+        super_render(render_context)
+      end
+    end
+  end
+
+end; end