volt 0.8.14 → 0.8.15

data/lib/volt/server/html_parser/sandlebars_parser.rb

@@ -1,222 +1,229 @@
 require 'strscan'
 
-class HTMLParseError < RuntimeError
-end
-# Parses html and bindings
-# based on http://ejohn.org/files/htmlparser.js
-#
-# takes the html and a handler object that will have the following methods
-# called as each is seen: comment, text, binding, start_tag, end_tag
-#
-# This is not a full html parser, but should cover most common cases.
-class SandlebarsParser
-  def self.truth_hash(array)
-    hash = {}
-    array.each {|v| hash[v] = true }
-
-    return hash
+module Volt
+  class HTMLParseError < RuntimeError
   end
 
-  # regex matchers
-  START_TAG = /^<([-!\:A-Za-z0-9_]+)((?:\s+[\w\-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/
-  END_TAG = /^<\/([-!\:A-Za-z0-9_]+)[^>]*>/
-  ATTRIBUTES = /([-\:A-Za-z0-9_]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/
+  # Parses html and bindings
+  # based on http://ejohn.org/files/htmlparser.js
+  #
+  # takes the html and a handler object that will have the following methods
+  # called as each is seen: comment, text, binding, start_tag, end_tag
+  #
+  # This is not a full html parser, but should cover most common cases.
+  class SandlebarsParser
+    def self.truth_hash(array)
+      hash = {}
+      array.each { |v| hash[v] = true }
+
+      return hash
+    end
 
-  # Types of elements
-  BLOCK = truth_hash(%w{a address applet blockquote button center dd del dir div dl dt fieldset form frameset hr iframe ins isindex li map menu noframes noscript object ol p pre script table tbody td tfoot th thead tr ul})
-  EMPTY = truth_hash(%w{area base basefont br col frame hr img input isindex link meta param embed})
-  INLINE = truth_hash(%w{abbr acronym applet b basefont bdo big br button cite code del dfn em font i iframe img input ins kbd label map object q s samp script select small span strike strong sub sup textarea tt u var})
-  CLOSE_SELF = truth_hash(%w{colgroup dd dt li options p td tfoot th thead tr})
-  SPECIAL = truth_hash(%w{script style})
+    # regex matchers
+    START_TAG  = /^<([-!\:A-Za-z0-9_]+)((?:\s+[\w\-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/
+    END_TAG    = /^<\/([-!\:A-Za-z0-9_]+)[^>]*>/
+    ATTRIBUTES = /([-\:A-Za-z0-9_]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/
 
-  FILL_IN_ATTRIBUTES = truth_hash(%w{checked compact declare defer disabled ismap multiple nohref noresize noshade nowrap readonly selected})
+    # Types of elements
+    BLOCK      = truth_hash(%w{a address applet blockquote button center dd del dir div dl dt fieldset form frameset hr iframe ins isindex li map menu noframes noscript object ol p pre script table tbody td tfoot th thead tr ul})
+    EMPTY      = truth_hash(%w{area base basefont br col frame hr img input isindex link meta param embed})
+    INLINE     = truth_hash(%w{abbr acronym applet b basefont bdo big br button cite code del dfn em font i iframe img input ins kbd label map object q s samp script select small span strike strong sub sup textarea tt u var})
+    CLOSE_SELF = truth_hash(%w{colgroup dd dt li options p td tfoot th thead tr})
+    SPECIAL    = truth_hash(%w{script style})
 
-  def initialize(html, handler, file_path=nil)
-    @html = StringScanner.new(html)
-    @handler = handler
-    @file_path = file_path
+    FILL_IN_ATTRIBUTES = truth_hash(%w{checked compact declare defer disabled ismap multiple nohref noresize noshade nowrap readonly selected})
 
-    @stack = []
+    def initialize(html, handler, file_path=nil)
+      @html      = StringScanner.new(html)
+      @handler   = handler
+      @file_path = file_path
 
-    parse
-  end
+      @stack = []
 
-  def last
-    @stack.last
-  end
+      parse
+    end
 
-  def parse
-    loop do
-      if last && SPECIAL[last]
-        # In a script or style tag, just look for the first end
-        close_tag = "</#{last}>"
-        body = @html.scan_until(/#{close_tag}/)
-        body = body[0..((-1 * close_tag.size)-1)]
-
-        body = body.gsub(/\<\!--(.*?)--\>/, "\\1").gsub(/\<\!\[CDATA\[(.*?)\]\]\>/, "\\1")
-
-        text(body)
-
-        end_tag(last, last)
-      elsif @html.scan(/\<\!--/)
-        # start comment
-        comment = @html.scan_until(/--\>/)
-        comment = comment[0..-4]
-
-        @handler.comment(comment) if @handler.respond_to?(:comment)
-      elsif (tag = @html.scan(START_TAG))
-        tag_name = @html[1]
-        rest = @html[2]
-        unary = @html[3]
-
-        start_tag(tag, tag_name, rest, unary)
-      elsif @html.scan(END_TAG)
-        tag_name = @html[1]
-
-        end_tag(tag_name, tag_name)
-      elsif (escaped = @html.scan(/\{\{\{(.*?)\}\}\}([^\}]|$)/))
-        # Anything between {{{ and }}} is escaped and not processed (treaded as text)
-        if escaped[-1] != '}'
-          # Move back if we matched a new non } for close, skip if we hit the end
-          @html.pos = @html.pos - 1
-        end
+    def last
+      @stack.last
+    end
 
-        text(@html[1])
-      elsif (binding = @html.scan(/\{\{/))
-        # We are in text mode and matched the start of a binding
-        start_binding
-      elsif (text = @html.scan(/\{/))
-        # A single { outside of a binding
-        text(text)
-      elsif (text = @html.scan(/(?:[^\<\{]+)/))
-        # matched text up until the next html tag
-        text(text)
-      else
-        # Nothing left
-        break
+    def parse
+      loop do
+        if last && SPECIAL[last]
+          # In a script or style tag, just look for the first end
+          close_tag = "</#{last}>"
+          body      = @html.scan_until(/#{close_tag}/)
+          special_tag(close_tag, body)
+        elsif @html.scan(/\<\!--/)
+          # start comment
+          comment = @html.scan_until(/--\>/)
+          comment = comment[0..-4]
+
+          @handler.comment(comment) if @handler.respond_to?(:comment)
+        elsif (tag = @html.scan(START_TAG))
+          tag_name = @html[1]
+          rest     = @html[2]
+          unary    = @html[3]
+
+          start_tag(tag, tag_name, rest, unary)
+        elsif @html.scan(END_TAG)
+          tag_name = @html[1]
+
+          end_tag(tag_name, tag_name)
+        elsif (escaped = @html.scan(/\{\{\{(.*?)\}\}\}([^\}]|$)/))
+          # Anything between {{{ and }}} is escaped and not processed (treaded as text)
+          if escaped[-1] != '}'
+            # Move back if we matched a new non } for close, skip if we hit the end
+            @html.pos = @html.pos - 1
+          end
+
+          text(@html[1])
+        elsif (binding = @html.scan(/\{\{/))
+          # We are in text mode and matched the start of a binding
+          start_binding
+        elsif (text = @html.scan(/\{/))
+          # A single { outside of a binding
+          text(text)
+        elsif (text = @html.scan(/(?:[^\<\{]+)/))
+          # matched text up until the next html tag
+          text(text)
+        else
+          # Nothing left
+          break
+        end
       end
-    end
 
-    end_tag(nil, nil)
-  end
+      end_tag(nil, nil)
+    end
 
-  def text(text)
-    @handler.text(text) if @handler.respond_to?(:text)
-  end
+    def text(text)
+      @handler.text(text) if @handler.respond_to?(:text)
+    end
 
-  # Findings the end of a binding
-  def start_binding
-    binding = ''
-    open_count = 1
-
-    # scan until we reach a {{ or }}
-    loop do
-      binding << @html.scan_until(/(\{\{|\}\}|\n|\Z)/)
-
-      match = @html[1]
-      if match == '}}'
-        # close
-        open_count -= 1
-        break if open_count == 0
-      elsif match == '{{'
-        # open more
-        open_count += 1
-      elsif match == "\n" || @html.eos?
-        # Starting new tag, should be closed before this
-        # or end of doc before closed binding
-        raise_parse_error("unclosed binding: {#{binding.strip}")
-      else
-        raise "should not reach here"
+    # Findings the end of a binding
+    def start_binding
+      binding    = ''
+      open_count = 1
+
+      # scan until we reach a {{ or }}
+      loop do
+        binding << @html.scan_until(/(\{\{|\}\}|\n|\Z)/)
+
+        match = @html[1]
+        if match == '}}'
+          # close
+          open_count -= 1
+          break if open_count == 0
+        elsif match == '{{'
+          # open more
+          open_count += 1
+        elsif match == "\n" || @html.eos?
+          # Starting new tag, should be closed before this
+          # or end of doc before closed binding
+          raise_parse_error("unclosed binding: {#{binding.strip}")
+        else
+          raise "should not reach here"
+        end
       end
-    end
 
-    binding = binding[0..-3]
-    @handler.binding(binding) if @handler.respond_to?(:binding)
-  end
+      binding = binding[0..-3]
+      @handler.binding(binding) if @handler.respond_to?(:binding)
+    end
 
-  def raise_parse_error(error)
-    line_number = @html.pre_match.count("\n") + 1
+    def raise_parse_error(error)
+      line_number = @html.pre_match.count("\n") + 1
 
-    error_str = error + " on line: #{line_number}"
-    error_str += " of #{@file_path}" if @file_path
+      error_str = error + " on line: #{line_number}"
+      error_str += " of #{@file_path}" if @file_path
 
-    raise HTMLParseError, error_str
-  end
+      raise HTMLParseError, error_str
+    end
 
-  def start_tag(tag, tag_name, rest, unary)
-    section_tag = tag_name[0] == ':' && tag_name[1] =~ /[A-Z]/
+    def start_tag(tag, tag_name, rest, unary)
+      section_tag = tag_name[0] == ':' && tag_name[1] =~ /[A-Z]/
 
-    tag_name = tag_name.downcase
+      tag_name = tag_name.downcase
 
-    # handle doctype so we get it output exactly the same way
-    if tag_name == '!doctype'
-      @handler.text(tag) if @handler.respond_to?(:start_tag)
-      return
-    end
+      # handle doctype so we get it output exactly the same way
+      if tag_name == '!doctype'
+        @handler.text(tag) if @handler.respond_to?(:start_tag)
+        return
+      end
 
-    # Auto-close the last inline tag if we started a new block
-    if BLOCK[tag_name]
-      if last && INLINE[last]
-        end_tag(nil, last)
+      # Auto-close the last inline tag if we started a new block
+      if BLOCK[tag_name]
+        if last && INLINE[last]
+          end_tag(nil, last)
+        end
       end
-    end
 
-    # Some tags close themselves when a new one of themselves is reached.
-    # ex, a tr will close the previous tr
-    if CLOSE_SELF[tag_name] && last == tag_name
-      end_tag(nil, tag_name)
-    end
+      # Some tags close themselves when a new one of themselves is reached.
+      # ex, a tr will close the previous tr
+      if CLOSE_SELF[tag_name] && last == tag_name
+        end_tag(nil, tag_name)
+      end
 
-    unary = EMPTY[tag_name] || !unary.blank?
+      unary = EMPTY[tag_name] || !unary.blank?
 
-    # Section tag's are also unary
-    unless unary || section_tag
-      @stack.push(tag_name)
-    end
+      # Section tag's are also unary
+      unless unary || section_tag
+        @stack.push(tag_name)
+      end
 
-    if @handler.respond_to?(:start_tag)
-      attributes = {}
+      if @handler.respond_to?(:start_tag)
+        attributes = {}
 
-      # Take the rest string and extract the attributes, filling in any
-      # "fill in" attribute values if not provided.
-      rest.scan(ATTRIBUTES).each do |match|
-        name = match[0]
+        # Take the rest string and extract the attributes, filling in any
+        # "fill in" attribute values if not provided.
+        rest.scan(ATTRIBUTES).each do |match|
+          name = match[0]
 
-        value = match[1] || match[2] || match[3] || FILL_IN_ATTRIBUTES[name] || ''
+          value = match[1] || match[2] || match[3] || FILL_IN_ATTRIBUTES[name] || ''
 
-        attributes[name] = value
-      end
+          attributes[name] = value
+        end
 
-      if section_tag
-        @handler.start_section(tag_name, attributes, unary)
-      else
-        @handler.start_tag(tag_name, attributes, unary)
+        if section_tag
+          @handler.start_section(tag_name, attributes, unary)
+        else
+          @handler.start_tag(tag_name, attributes, unary)
+        end
       end
     end
-  end
-
-  def end_tag(tag, tag_name)
-    # If no tag name is provided, close all the way up
-    new_size = 0
 
-    if tag
-      # Find the closest tag that closes.
-      (@stack.size-1).downto(0) do |index|
-        if @stack[index] == tag_name
-          new_size = index
-          break
+    def end_tag(tag, tag_name)
+      # If no tag name is provided, close all the way up
+      new_size = 0
+
+      if tag
+        # Find the closest tag that closes.
+        (@stack.size-1).downto(0) do |index|
+          if @stack[index] == tag_name
+            new_size = index
+            break
+          end
         end
       end
-    end
 
-    if new_size >= 0
-      if @handler.respond_to?(:end_tag)
-        (@stack.size-1).downto(new_size) do |index|
-          @handler.end_tag(@stack[index])
+      if new_size >= 0
+        if @handler.respond_to?(:end_tag)
+          (@stack.size-1).downto(new_size) do |index|
+            @handler.end_tag(@stack[index])
+          end
         end
+
+        @stack = @stack[0...new_size]
       end
+    end
+
+    def special_tag(close_tag, body)
+      body = body[0..((-1 * close_tag.size)-1)]
+
+      body = body.gsub(/\<\!--(.*?)--\>/, "\\1").gsub(/\<\!\[CDATA\[(.*?)\]\]\>/, "\\1")
 
-      @stack = @stack[0...new_size]
+      text(body)
+
+      end_tag(last, last)
     end
   end
-end
+end

data/lib/volt/server/html_parser/textarea_scope.rb

@@ -1,31 +1,33 @@
-class TextareaScope < ViewScope
-  def initialize(handler, path, attributes)
-    super(handler, path)
+module Volt
+  class TextareaScope < ViewScope
+    def initialize(handler, path, attributes)
+      super(handler, path)
 
-    @attributes = attributes
-  end
+      @attributes = attributes
+    end
 
-  def add_binding(content)
-    @html << "{{#{content}}}"
-  end
+    def add_binding(content)
+      @html << "{{#{content}}}"
+    end
 
-  def close_scope(pop=true)
-    # Remove from the scope
-    @handler.scope.pop
+    def close_scope(pop=true)
+      # Remove from the scope
+      @handler.scope.pop
 
-    attributes = @attributes
+      attributes = @attributes
 
-    if @html[/\{\{[^\}]+\}\}/]
-      # If the html inside the textarea has a binding, process it as
-      # a value attribute.
-      attributes['value'] = @html
-      @html = ''
-    end
+      if @html[/\{\{[^\}]+\}\}/]
+        # If the html inside the textarea has a binding, process it as
+        # a value attribute.
+        attributes['value'] = @html
+        @html               = ''
+      end
 
-    # Normal tag
-    attributes = @handler.last.process_attributes('textarea', attributes)
+      # Normal tag
+      attributes = @handler.last.process_attributes('textarea', attributes)
 
-    @handler.last.html << "<textarea#{attribute_string(attributes)}>#{@html}</textarea>"
+      @handler.last.html << "<textarea#{attribute_string(attributes)}>#{@html}</textarea>"
 
+    end
   end
-end
+end

data/lib/volt/server/html_parser/view_handler.rb

@@ -1,82 +1,83 @@
-class ViewHandler
-  attr_reader :templates, :scope
+module Volt
+  class ViewHandler
+    attr_reader :templates, :scope
 
-  def html
-    last.html
-  end
-
-  def last
-    @scope.last
-  end
+    def html
+      last.html
+    end
 
-  def initialize(initial_path, allow_sections=true)
-    @original_path = initial_path
+    def last
+      @scope.last
+    end
 
-    # Default to the body section
-    initial_path += '/body' if allow_sections
+    def initialize(initial_path, allow_sections=true)
+      @original_path = initial_path
 
-    @scope = [ViewScope.new(self, initial_path)]
-    @templates = {}
-  end
+      # Default to the body section
+      initial_path   += '/body' if allow_sections
 
-  def comment(comment)
-    last << "<!--#{comment}-->"
-  end
-
-  def text(text)
-    last << text
-  end
+      @scope     = [ViewScope.new(self, initial_path)]
+      @templates = {}
+    end
 
-  def binding(binding)
-    @scope.last.add_binding(binding)
-  end
+    def comment(comment)
+      last << "<!--#{comment}-->"
+    end
 
-  def start_tag(tag_name, attributes, unary)
-    case tag_name[0]
-    when ':'
-      # Component
-      last.add_component(tag_name, attributes, unary)
-    else
-      if tag_name == 'textarea'
-        @in_textarea = true
-        last.add_textarea(tag_name, attributes, unary)
-      else
+    def text(text)
+      last << text
+    end
 
-        # Normal tag
-        attributes = last.process_attributes(tag_name, attributes)
-        attr_str = last.attribute_string(attributes)
+    def binding(binding)
+      @scope.last.add_binding(binding)
+    end
 
-        last << "<#{tag_name}#{attr_str}#{unary ? ' /' : ''}>"
+    def start_tag(tag_name, attributes, unary)
+      case tag_name[0]
+        when ':'
+          # Component
+          last.add_component(tag_name, attributes, unary)
+        else
+          if tag_name == 'textarea'
+            @in_textarea = true
+            last.add_textarea(tag_name, attributes, unary)
+          else
+
+            # Normal tag
+            attributes = last.process_attributes(tag_name, attributes)
+            attr_str   = last.attribute_string(attributes)
+
+            last << "<#{tag_name}#{attr_str}#{unary ? ' /' : ''}>"
+          end
       end
     end
-  end
 
-  def end_tag(tag_name)
-    if @in_textarea && tag_name == 'textarea'
-      last.close_scope
-      @in_textarea = nil
-    else
-      last << "</#{tag_name}>"
+    def end_tag(tag_name)
+      if @in_textarea && tag_name == 'textarea'
+        last.close_scope
+        @in_textarea = nil
+      else
+        last << "</#{tag_name}>"
+      end
     end
-  end
 
-  def start_section(tag_name, attributes, unary)
-    path = last.path
-    # Start of section
-    if @in_section
-      # Close any previous sections
-      last.close_scope
-    else
-      # This is the first time we've hit a section header, everything
-      # outside of the headers should be removed
-      @templates = {}
-    end
+    def start_section(tag_name, attributes, unary)
+      path = last.path
+      # Start of section
+      if @in_section
+        # Close any previous sections
+        last.close_scope
+      else
+        # This is the first time we've hit a section header, everything
+        # outside of the headers should be removed
+        @templates = {}
+      end
 
-    @in_section = tag_name[1..-1]
+      @in_section = tag_name[1..-1]
 
-    # Set the new path to include the section
-    new_path = @original_path + '/' + @in_section
-    @scope = [ViewScope.new(self, new_path)]
+      # Set the new path to include the section
+      new_path    = @original_path + '/' + @in_section
+      @scope      = [ViewScope.new(self, new_path)]
+    end
   end
-
-end
+end

data/lib/volt/server/html_parser/view_parser.rb

@@ -5,35 +5,37 @@ require 'volt/server/html_parser/view_handler'
 require 'volt/server/html_parser/each_scope'
 require 'volt/server/html_parser/textarea_scope'
 
-class ViewParser
-  attr_reader :templates
+module Volt
+  class ViewParser
+    attr_reader :templates
 
-  def initialize(html, template_path)
-    @template_path = template_path
+    def initialize(html, template_path)
+      @template_path = template_path
 
-    handler = ViewHandler.new(template_path)
+      handler = ViewHandler.new(template_path)
 
-    SandlebarsParser.new(html, handler)
+      SandlebarsParser.new(html, handler)
 
-    # Close out the last scope
-    handler.scope.last.close_scope
+      # Close out the last scope
+      handler.scope.last.close_scope
 
-    @templates = handler.templates
-  end
+      @templates = handler.templates
+    end
 
-  # Returns a parsed version of the data (useful for backend rendering
-  # and testing)
-  def data
-    templates = @templates.deep_clone
+    # Returns a parsed version of the data (useful for backend rendering
+    # and testing)
+    def data
+      templates = @templates.deep_clone
 
-    templates.each_pair do |name, value|
-      if value['bindings']
-        value['bindings'].each_pair do |number, binding|
-          value['bindings'][number] = binding.map {|code| eval(code) }
+      templates.each_pair do |name, value|
+        if value['bindings']
+          value['bindings'].each_pair do |number, binding|
+            value['bindings'][number] = binding.map { |code| eval(code) }
+          end
         end
       end
-    end
 
-    return templates
+      return templates
+    end
   end
-end
+end