mullet 0.0.0

data/lib/mullet.rb

@@ -0,0 +1,8 @@
+require 'mullet/default_model'
+require 'mullet/default_nested_model'
+require 'mullet/model'
+require 'mullet/template_error'
+require 'mullet/version'
+
+require 'mullet/html/template'
+require 'mullet/html/template_loader'

data/lib/mullet/container.rb

@@ -0,0 +1,33 @@
+module Mullet
+
+  # Collection of renderers which will be rendered in the order they were added.
+  module Container
+    def initialize()
+      super if defined?(super)
+      @children = []
+    end
+
+    def add_child(child)
+      @children << child
+    end
+
+    def delete_child(child)
+      @children.delete(child);
+    end
+
+    def clear_children()
+      @children.clear()
+    end
+
+    # Renders children in order they were added.
+    # 
+    # @param [RenderContext] renderContext
+    #           render context
+    def render_children(renderContext)
+      @children.each do |child|
+        child.render(renderContext)
+      end
+    end
+  end
+
+end

data/lib/mullet/default_model.rb

@@ -0,0 +1,67 @@
+require 'mullet/model'
+
+module Mullet
+
+  # Default model implementation which resolves variable names to values by
+  # reading from a data object. Given a variable name _key_, the following
+  # mechanisms are tried in this order:
+  #
+  #   * If the variable name is `this`, then return the object.
+  #   * If the object is a `Hash`, then use _key_ as the key to retrieve the
+  #     value from the hash.
+  #   * If the object has a method named _key_ taking no parameters, then use
+  #     the value returned from calling the method.
+  #   * If the object has an instance variable named @_key_, then use the
+  #     variable value.
+  #
+  # If the value is a Proc, then use the value returned from calling it.
+  class DefaultModel
+    include Model
+
+    def initialize(data)
+      @data = data
+    end
+
+    def fetch_impl(key)
+      if key == :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) }
+      end
+
+      # Does the variable name match a method name in the object?
+      if @data.respond_to?(key)
+        method = @data.method(key)
+        if method.arity == 0
+          return method.call()
+        end
+      end
+
+      # Does the variable name match an instance variable name in the object?
+      variable = :"@#{key}"
+      if @data.instance_variable_defined?(variable)
+        return @data.instance_variable_get(variable)
+      end
+
+      return NOT_FOUND
+    end
+
+    # Resolves variable name to value.
+    # 
+    # @param [Symbol] key
+    #           variable name
+    # @return variable value
+    def fetch(key)
+      value = fetch_impl(key)
+      if value.is_a?(Proc)
+        value = value.call()
+      end
+      return value
+    end
+  end
+
+end

data/lib/mullet/default_nested_model.rb

@@ -0,0 +1,49 @@
+require 'mullet/default_model'
+
+module Mullet
+
+  # Composite model that combines models in nested scopes. Tries each model in
+  # sequence until a value is successfully resolved.
+  class DefaultNestedModel
+    include Model
+
+    # Constructor
+    # 
+    # @param dataObjects
+    #           scopes in outer to inner order
+    def initialize(*dataObjects)
+      @scopes = []
+      dataObjects.each {|data| push_scope(data) }
+    end
+
+    # Resolves variable name to value.
+    # 
+    # @param [Symbol] key
+    #           variable name
+    # @return variable value
+    def fetch(key)
+      @scopes.reverse_each do |scope|
+        value = scope.fetch(key)
+        if value != Model::NOT_FOUND
+          return value
+        end
+      end
+
+      return Model::NOT_FOUND
+    end
+
+    # Adds a nested scope to search in subsequent lookups.
+    #
+    # @param data
+    #           data object
+    def push_scope(data)
+      @scopes.push(data.is_a?(Model) ? data : DefaultModel.new(data))
+    end
+
+    # Removes innermost nested scope.
+    def pop_scope()
+      @scopes.pop()
+    end
+  end
+
+end

data/lib/mullet/html/attribute_command.rb

@@ -0,0 +1,32 @@
+module Mullet
+
+  # Operation to set attribute value.
+  module AttributeCommand
+
+    # Constructor
+    #
+    # @param [Symbol] attribute_name
+    #           name of attribute this command sets
+    def initialize(attribute_name)
+      @attribute_name = attribute_name
+    end
+
+    # Sets attribute in the _attributecommand.
+    #
+    # @param [RenderContext] render_context
+    #           render context
+    # @param [Attributes] attributes
+    #           attributes to update
+    def execute(render_context, attributes)
+      value = get_value(render_context)
+      if value == Model::NOT_FOUND || value == nil
+        # Value not found.  Do not render the attribute.
+        attributes.delete(@attribute_name)
+      else
+        escaped_value = render_context.escape_xml(value)
+        attributes.store(@attribute_name, escaped_value)
+      end
+    end
+  end
+
+end

data/lib/mullet/html/command.rb

@@ -0,0 +1,29 @@
+module Mullet
+
+  # Recognized template commands
+  module Command
+    PREFIX = 'mullet:'
+    NAMESPACE_URI = 'http://pukkaone.github.com/mullet/1'
+
+    ACTION = 'action'
+    ALT = 'alt'
+    ALT_MESSAGE = 'alt-message'
+    ATTR = 'attr'
+    ATTR_MESSAGE = 'attr-message'
+    ESCAPE_XML = 'escape-xml'
+    FOR = 'for'
+    HREF = 'href'
+    IF = 'if'
+    INCLUDE = 'include'
+    REMOVE = 'remove'
+    SRC = 'src'
+    TEXT = 'text'
+    TEXT_MESSAGE = 'text-message'
+    TITLE = 'title'
+    TITLE_MESSAGE = 'title-message'
+    UNLESS = 'unless'
+    VALUE = 'value'
+    VALUE_MESSAGE = 'value-message'
+  end
+
+end

data/lib/mullet/html/template_builder.rb

@@ -0,0 +1,142 @@
+require 'nokogiri'
+require 'mullet/html/command'
+require 'set'
+
+module Mullet; module HTML
+
+  # Handles SAX events to build a template.
+  class TemplateBuilder < Nokogiri::XML::SAX::Document
+    include Command
+
+    XMLNS_ATTRIBUTE_PREFIX = "xmlns:"
+    COMMANDS = [
+        ATTRIBUTE,
+        ATTRIBUTE_MESSAGE,
+        CONTENT,
+        ESCAPE_XML,
+        FOR,
+        IF,
+        INCLUDE,
+        TEXT,
+        TEXT_MESSAGE,
+        UNLESS].to_set
+    START_CDATA = "<![CDATA["
+    END_CDATA = "]]>"
+
+    @loader = nil
+
+    # 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
+    end
+
+    # Adds renderer to current container.
+    #
+    # @param [#render] renderer
+    #           renderer to add
+    def add_child(renderer)
+      @containers.last.add_child(renderer)
+    end
+
+    # Deletes renderer from current container.
+    #
+    # @param [#render] renderer
+    #           renderer to delete
+    def delete_child(renderer)
+      @containers.last.delete_child(renderer)
+    end
+
+    # Partitions the attributes into ordinary and command attributes.
+    #
+    # @param [Array] attributes
+    #           input attributes
+    # @param [Hash] ns
+    #           hash of namespace prefix to uri mappings
+    # @param [#store] ordinaryAttributes
+    #           hash will receive name to value mappings for ordinary attributes
+    # @param [#store] commandAttributes
+    #           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
+      attributes.each do |attr|
+        if attr.uri == NAMESPACE_URI
+          commandName = attr.localname
+          if !COMMANDS.contains(commandName)
+            raise TemplateException("invalid command '#{commandName}'")
+          end
+          commandAttributes.store(commandName, attr.value)
+          foundCommand = true
+        else
+          attributeName = [attr.prefix, attr.localname].compact.join(':')
+          ordinaryAttributes.store(attributeName, attr.value)
+        end
+      end
+
+      ns.each do |prefix, uri|
+        if uri != NAMESPACE_URI
+          attributeName = ['xmlns', prefix].compact.join(':')
+          ordinaryAttributes.store(attributeName, uri)
+        end
+      end
+
+      return foundCommand
+    end
+
+    def render_start_tag(name, attributes, prefix, uri, namespaceDecls)
+      tag = "<"
+      if prefix
+        tag << prefix << ":"
+      end
+      tag << name
+
+      attributes.each do |attribute|
+        tag << " "
+        if attribute.prefix
+          tag << attribute.prefix << ":"
+        end
+        tag = attribute.localname << '="' << attribute.value << '"'
+      end
+
+      namespaceDecls.each do |namespaceDecl|
+        uri = namespaceDecl[1] 
+        if uri != TEMPLATE_NAMESPACE_URI
+          tag << " xmlns:" << namespaceDecl[0] << '="' << uri << '"'
+        end
+      end
+
+      tag << ">"
+      return tag
+    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)
+      else
+        puts "attributes #{templateAttributes}"
+      end
+    end
+
+    def end_document
+      puts "the document has ended"
+    end
+  end
+
+end; end

data/lib/mullet/html/template_loader.rb

@@ -0,0 +1,55 @@
+require 'nokogiri'
+
+module Mullet
+
+class TemplateDocument < Nokogiri::XML::SAX::Document
+  TEMPLATE_NAMESPACE_URI = "http://pukkaone.github.com/mullet/1"
+
+  def render_start_tag(name, attributes, prefix, uri, namespaceDecls)
+    tag = "<"
+    if prefix
+      tag << prefix << ":"
+    end
+    tag << name
+
+    attributes.each do |attribute|
+      tag << " "
+      if attribute.prefix
+        tag << attribute.prefix << ":"
+      end
+      tag = attribute.localname << '="' << attribute.value << '"'
+    end
+
+    namespaceDecls.each do |namespaceDecl|
+      uri = namespaceDecl[1] 
+      if uri != TEMPLATE_NAMESPACE_URI
+        tag << " xmlns:" << namespaceDecl[0] << '="' << uri << '"'
+      end
+    end
+
+    tag << ">"
+    return tag
+  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)
+    else
+      puts "attributes #{templateAttributes}"
+    end
+  end
+
+  def end_document
+    puts "the document has ended"
+  end
+end
+
+parser = Nokogiri::HTML::SAX::Parser.new(TemplateDocument.new)
+f = File.open("login.html")
+parser.parse(f)
+f.close
+end

data/lib/mullet/model.rb

@@ -0,0 +1,14 @@
+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.
+  module Model
+
+    # special value indicating variable name was not found
+    NOT_FOUND = Object.new()
+  end
+
+end

data/lib/mullet/render_context.rb

@@ -0,0 +1,84 @@
+module Mullet
+
+  # Holds the rendering context to reduce the number of parameters passed to
+  # render methods.
+  class RenderContext
+    attr_accessor :escapeXmlEnabled
+
+    # Constructor.
+    #
+    # @param [Model] model
+    #           provides data to render
+    # @param [Proc] missingValueStrategy
+    #           executed on attempt to render a variable that was not found 
+    # @param [Proc] nilValueStrategy
+    #           executed on attempt to render nil value
+    # @param [#<<] output
+    #           where rendered output will be written
+    def initialize(model, missingValueStrategy, nilValueStrategy, output)
+      @model = model
+      @missingValueStrategy = missingValueStrategy
+      @nilValueStrategy = nilValueStrategy
+      @output = output
+      @escapeXmlEnabled = true
+    end
+
+    # Escapes characters that could be interpreted as XML markup if enabled.
+    #
+    # @param [String] input
+    #           input string
+    # @return escaped string, or the input string if escaping is disabled.
+    def escape_xml(key)
+      return @escapeXmlEnabled ? CGI.escape_html(input) : input
+    end
+
+    # Resolves variable name to value.
+    #
+    # @param [Symbol] key
+    #           variable name
+    # @return value
+    def fetch(key)
+      return @model.fetch(key)
+    end
+
+    # Adds a nested scope to search in subsequent lookups.
+    #
+    # @param data
+    #           data object
+    def push_scope(data)
+      @model.push_scope(data)
+    end
+
+    # Removes innermost nested scope.
+    def pop_scope()
+      @model.pop_scope()
+    end
+
+    # Gets model value that is intended for display in the rendered output.
+    # Applies configured strategies for handling missing and nil values.
+    #
+    # @param [Symbol] key
+    #           variable name
+    def get_display_value(key)
+      value = @model.fetch(key)
+      if value == Model::NOT_FOUND
+        value = @missingValueStrategy.call(key)
+      end
+      if value == nil
+        value = @nilValueStrategy.call(key)
+      end
+      return value
+    end
+
+    # Writes rendered output.
+    #
+    # @param [String] str
+    #           string to write
+    # @return this object
+    def <<(str)
+      @output << str
+      return self
+    end
+  end
+
+end

data/lib/mullet/template_error.rb

@@ -0,0 +1,6 @@
+module Mullet
+
+  class TemplateError < StandardError
+  end
+
+end

data/lib/mullet/version.rb

@@ -0,0 +1,3 @@
+module Mullet
+  VERSION = '0.0.0'
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: mullet
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Chin Huang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2152289140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152289140
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2152288740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152288740
+description: ! "It's like mustache but in HTML syntax.\n\n  * Extremely simple variable
+  syntax is incapable of expressing logic in the\n    templates.\n  * Templates are
+  clean HTML.  Your HTML authoring tool and browser will\n    correctly display the
+  templates while you prototype your user interface.\n"
+email: pukkaone@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mullet/container.rb
+- lib/mullet/default_model.rb
+- lib/mullet/default_nested_model.rb
+- lib/mullet/html/attribute_command.rb
+- lib/mullet/html/command.rb
+- lib/mullet/html/template_builder.rb
+- lib/mullet/html/template_loader.rb
+- lib/mullet/model.rb
+- lib/mullet/render_context.rb
+- lib/mullet/template_error.rb
+- lib/mullet/version.rb
+- lib/mullet.rb
+homepage: http://pukkaone.github.com/mullet/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: nowarning
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Logic-less HTML template engine
+test_files: []