volt 0.6.5 → 0.7.0

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

@@ -0,0 +1,116 @@
+# Included into ViewScope to provide processing for attributes
+module AttributeScope
+  # Take the attributes and create any bindings
+  def process_attributes(tag_name, attributes)
+    new_attributes = attributes.dup
+
+    attributes.each_pair do |name, value|
+      if name[0..1] == 'e-'
+        process_event_binding(tag_name, new_attributes, name, value)
+      else
+        process_attribute(tag_name, new_attributes, name, value)
+      end
+    end
+
+    return new_attributes
+  end
+
+  def process_event_binding(tag_name, attributes, name, value)
+    id = add_id_to_attributes(attributes)
+
+    event = name[2..-1]
+
+    if tag_name == 'a'
+      # For links, we need to add blank href to make it clickable.
+      attributes['href'] ||= ''
+    end
+
+    # Remove the e- attribute
+    attributes.delete(name)
+
+    save_binding(id, "lambda { |__p, __t, __c, __id| EventBinding.new(__p, __t, __c, __id, #{event.inspect}, Proc.new {|event| #{value} })}")
+  end
+
+  def process_attribute(tag_name, attributes, attribute_name, value)
+    parts = value.split(/(\{[^\}]+\})/).reject(&:blank?)
+    binding_count = parts.count {|p| p[0] == '{' && p[-1] == '}'}
+
+    # if this attribute has bindings
+    if binding_count > 0
+      # Setup an id
+      id = add_id_to_attributes(attributes)
+
+      if parts.size > 1
+        # Multiple bindings
+        add_multiple_attribute(tag_name, id, attribute_name, parts, value)
+      elsif parts.size == 1 && binding_count == 1
+        # A single binding
+        add_single_attribute(id, attribute_name, parts)
+      end
+
+      # Remove the attribute
+      attributes.delete(attribute_name)
+    end
+  end
+
+  # Add an attribute binding on the tag, bind directly to the getter in the binding
+  def add_single_attribute(id, attribute_name, parts)
+    getter = parts[0][1..-2]
+
+    save_binding(id, "lambda { |__p, __t, __c, __id| AttributeBinding.new(__p, __t, __c, __id, #{attribute_name.inspect}, Proc.new { #{getter} }) }")
+  end
+
+
+  def add_multiple_attribute(tag_name, id, attribute_name, parts, content)
+    case attribute_name
+    when 'checked', 'value'
+      if parts.size > 1
+        if tag_name == 'textarea'
+          raise "The content of text area's can not be bound to multiple bindings."
+        else
+          # Multiple ReactiveValue's can not be passed to value or checked attributes.
+          raise "Multiple bindings can not be passed to a #{attribute_name} binding."
+        end
+      end
+    end
+
+    reactive_template_path = add_reactive_template(content)
+
+    save_binding(id, "lambda { |__p, __t, __c, __id| AttributeBinding.new(__p, __t, __c, __id, #{attribute_name.inspect}, Proc.new { ReactiveTemplate.new(__p, __c, #{reactive_template_path.inspect}) }) }")
+  end
+
+  def add_reactive_template(content)
+    path = @path + "/_rv#{@binding_number}"
+    new_handler = ViewHandler.new(path, false)
+    @binding_number += 1
+
+    SandlebarsParser.new(content, new_handler)
+
+    # Close out the last scope
+    new_handler.scope.last.close_scope
+
+    # Copy in the templates from the new handler
+    new_handler.templates.each_pair do |key, value|
+      @handler.templates[key] = value
+    end
+
+    return path
+  end
+
+  def add_id_to_attributes(attributes)
+    id = attributes['id'] ||= "id#{@binding_number}"
+    @binding_number += 1
+
+    return id.to_s
+  end
+
+  def attribute_string(attributes)
+    attr_str = attributes.map {|v| "#{v[0]}=\"#{v[1]}\"" }.join(' ')
+    if attr_str.size > 0
+      # extra space
+      attr_str = " " + attr_str
+    end
+
+    return attr_str
+  end
+end

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

@@ -0,0 +1,18 @@
+class EachScope < ViewScope
+  def initialize(handler, path, content)
+    super(handler, path)
+    @content, @variable_name = content.strip.split(/ as /)
+  end
+  
+  def close_scope
+    binding_number = @handler.scope[-2].binding_number
+    @handler.scope[-2].binding_number += 1
+    @path += "/__template/#{binding_number}"
+    
+    super
+    
+    @handler.html << "<!-- $#{binding_number} --><!-- $/#{binding_number} -->"
+		@handler.scope.last.save_binding(binding_number, "lambda { |__p, __t, __c, __id| EachBinding.new(__p, __t, __c, __id, Proc.new { #{@content} }, #{@variable_name.inspect}, #{@path.inspect}) }")
+    
+  end
+end

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

@@ -0,0 +1,71 @@
+class IfViewScope < ViewScope
+  def initialize(handler, path, content)
+    super(handler, path)
+    
+    @original_path = @path
+    
+    @last_content = content
+    @branches = []
+    
+    # We haven't added the if yet
+    @if_binding_number = @handler.last.binding_number
+    @handler.last.binding_number += 1
+    
+    @path_number = 0
+    
+    new_path
+  end
+  
+  def new_path
+    @path = @original_path + "/__if#{@path_number}"
+    @path_number += 1
+  end
+
+  # When we reach an else block, we basically commit the current html
+  # and template, and start a new one.
+  def add_else(content)
+    close_scope(false)
+
+    @last_content = content
+    
+    # Clear existing
+    @html = ''
+    @bindings = {}
+    
+    # Close scope removes us, so lets add it back.
+    @handler.scope << self
+    
+    @binding_number = 0
+
+    # Generate a new template path for this section.
+    new_path
+  end
+  
+  def close_scope(final=true)
+    @branches << [@last_content, path]    
+
+    super()
+
+    if final    
+      # Add the binding to the parent
+      branches = @branches.map do |branch|
+        content = branch[0]
+        if content == nil
+          content = nil.inspect
+        else
+          content = "Proc.new { #{branch[0]} }"
+        end
+      
+        "[#{content}, #{branch[1].inspect}]"
+      end.join(', ')
+    
+      new_scope = @handler.last
+
+      # variables are captured for branches, so we must prefix them so they don't conflict.
+      # page, target, context, id
+      new_scope.save_binding(@if_binding_number, "lambda { |__p, __t, __c, __id| IfBinding.new(__p, __t, __c, __id, [#{branches}]) }")
+    
+      new_scope.html << "<!-- $#{@if_binding_number} --><!-- $/#{@if_binding_number} -->"
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+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
+  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]+)))?/
+
+  # Types of elements
+  BLOCK = truth_hash(%w{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{a 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})
+  
+  FILL_IN_ATTRIBUTES = truth_hash(%w{checked compact declare defer disabled ismap multiple nohref noresize noshade nowrap readonly selected})
+  
+  def initialize(html, handler, file_path=nil)
+    @html = StringScanner.new(html)
+    @handler = handler
+    @file_path = file_path
+    
+    @stack = []
+    
+    parse
+  end
+  
+  def last
+    @stack.last
+  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
+        
+        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(/(?:[^\<\{]+)/))
+        # matched text up until the next html tag
+        text(text)
+      else
+        # Nothing left
+        break
+      end
+    end
+    
+    end_tag(nil, nil)
+  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"
+      end
+    end
+    
+    binding = binding[0..-2]
+    @handler.binding(binding) if @handler.respond_to?(:binding)    
+  end
+  
+  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
+
+    raise HTMLParseError, error_str
+  end
+  
+  def start_tag(tag, tag_name, rest, unary)
+    section_tag = tag_name[0] == ':' && tag_name[1] =~ /[A-Z]/
+    
+    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
+
+    # 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
+    
+    # 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?
+    
+    # Section tag's are also unary
+    unless unary || section_tag
+      @stack.push(tag_name)
+    end
+    
+    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]
+        
+        value = match[1] || match[2] || match[3] || FILL_IN_ATTRIBUTES[name] || ''
+        
+        attributes[name] = value
+      end
+      
+      if section_tag
+        @handler.start_section(tag_name, attributes, unary)
+      else
+        @handler.start_tag(tag_name, attributes, unary)
+      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
+        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])
+        end
+      end
+
+      @stack = @stack[0...new_size]
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+class TextareaScope < ViewScope
+  def initialize(handler, path, attributes)
+    super(handler, path)
+
+    @attributes = attributes
+  end
+
+  def add_binding(content)
+    @html << "{#{content}}"
+  end
+
+  def close_scope(pop=true)
+    # Remove from the scope
+    @handler.scope.pop
+
+    attributes = @attributes
+
+    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)
+
+    @handler.last.html << "<textarea#{attribute_string(attributes)}>#{@html}</textarea>"
+
+  end
+end

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

@@ -0,0 +1,82 @@
+class ViewHandler
+  attr_reader :templates, :scope
+
+  def html
+    last.html
+  end
+
+  def last
+    @scope.last
+  end
+
+  def initialize(initial_path, allow_sections=true)
+    @original_path = initial_path
+
+    # Default to the body section
+    initial_path += '/body' if allow_sections
+
+    @scope = [ViewScope.new(self, initial_path)]
+    @templates = {}
+  end
+
+  def comment(comment)
+    last << "<!--#{comment}-->"
+  end
+
+  def text(text)
+    last << text
+  end
+
+  def binding(binding)
+    @scope.last.add_binding(binding)
+  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
+
+        # Normal tag
+        attributes = last.process_attributes(tag_name, attributes)
+        attr_str = last.attribute_string(attributes)
+
+        last << "<#{tag_name}#{attr_str}#{unary ? ' /' : ''}>"
+      end
+    end
+  end
+
+  def end_tag(tag_name)
+    if @in_textarea && tag_name == 'textarea'
+      last.close_scope
+      @in_textarea = nil
+    else
+      last << "</#{tag_name}>"
+    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
+
+    @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)]
+  end
+
+end

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

@@ -0,0 +1,23 @@
+require 'volt/server/html_parser/sandlebars_parser'
+require 'volt/server/html_parser/view_scope'
+require 'volt/server/html_parser/if_view_scope'
+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
+  
+  def initialize(html, template_path)
+    @template_path = template_path
+
+    handler = ViewHandler.new(template_path)
+    
+    SandlebarsParser.new(html, handler)
+    
+    # Close out the last scope
+    handler.scope.last.close_scope
+    
+    @templates = handler.templates
+  end
+end

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

@@ -0,0 +1,145 @@
+require 'volt/server/html_parser/attribute_scope'
+
+class ViewScope
+  include AttributeScope
+
+  attr_reader :html, :bindings
+  attr_accessor :path, :binding_number
+
+  def initialize(handler, path)
+    @handler = handler
+    @path = path
+
+    @html = ''
+    @bindings = {}
+    @binding_number = 0
+  end
+
+  def <<(html)
+    @html << html
+  end
+
+  def add_binding(content)
+    case content[0]
+    when '#'
+  		command, *content = content.split(/ /)
+  		content = content.join(' ')
+
+      case command
+      when '#if'
+        add_if(content)
+      when '#elsif'
+        add_else(content)
+      when '#else'
+        if content.blank?
+          add_else(nil)
+        else
+          raise "#else does not take a conditional #{content} was provided."
+        end
+      when '#each'
+        add_each(content)
+      when '#template'
+        add_template(content)
+      end
+    when '/'
+      # close binding
+      close_scope
+    else
+      # content
+      add_content_binding(content)
+    end
+  end
+
+  def add_content_binding(content)
+    @handler.html << "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
+    save_binding(@binding_number, "lambda { |__p, __t, __c, __id| ContentBinding.new(__p, __t, __c, __id, Proc.new { #{content} }) }")
+    @binding_number += 1
+  end
+
+  def add_if(content)
+    # Add with path for if group.
+    @handler.scope << IfViewScope.new(@handler, @path + "/__ifg#{@binding_number}", content)
+    @binding_number += 1
+  end
+
+  def add_else(content)
+    raise "#else can only be added inside of an if block"
+  end
+
+  def add_each(content)
+    @handler.scope << EachScope.new(@handler, @path, content)
+  end
+
+  def add_template(content)
+    @handler.html << "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
+    save_binding(@binding_number, "lambda { |__p, __t, __c, __id| TemplateBinding.new(__p, __t, __c, __id, #{@path.inspect}, Proc.new { [#{content}] }) }")
+
+    @binding_number += 1
+  end
+
+  def add_component(tag_name, attributes, unary)
+    component_name = tag_name[1..-1].gsub(':', '/')
+
+    @handler.html << "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
+
+    data_hash = []
+    attributes.each_pair do |name, value|
+      parts = value.split(/(\{[^\}]+\})/).reject(&:blank?)
+      binding_count = parts.count {|p| p[0] == '{' && p[-1] == '}'}
+
+      # if this attribute has bindings
+      if binding_count > 0
+        if binding_count > 1
+          # Multiple bindings
+        elsif parts.size == 1 && binding_count == 1
+          # A single binding
+          data_hash << "#{name.inspect} => Proc.new { #{value[1..-2]} }"
+        end
+      else
+        # String
+        data_hash << "#{name.inspect} => #{value.inspect}"
+      end
+    end
+
+    arguments = "#{component_name.inspect}, { #{data_hash.join(',')} }"
+
+    save_binding(@binding_number, "lambda { |__p, __t, __c, __id| ComponentBinding.new(__p, __t, __c, __id, #{@path.inspect}, Proc.new { [#{arguments}] }) }")
+
+    @binding_number += 1
+  end
+
+  def add_textarea(tag_name, attributes, unary)
+    @handler.scope << TextareaScope.new(@handler, @path + "/__txtarea#{@binding_number}", attributes)
+    @binding_number += 1
+
+    # close right away if unary
+    @handler.last.close_scope if unary
+  end
+
+  # Called when this scope should be closed out
+  def close_scope(pop=true)
+    if pop
+      scope = @handler.scope.pop
+    else
+      scope = @handler.last
+    end
+
+    raise "template path already exists: #{scope.path}" if @handler.templates[scope.path]
+
+    template = {
+      'html' => scope.html
+    }
+
+    if scope.bindings.size > 0
+      # Add the bindings if there are any
+      template['bindings'] = scope.bindings
+    end
+
+    @handler.templates[scope.path] = template
+  end
+
+  def save_binding(binding_number, code)
+    @bindings[binding_number] ||= []
+    @bindings[binding_number] << code
+  end
+end