volt 0.2.3

data/lib/volt/server/source_map_server.rb

@@ -0,0 +1,31 @@
+class SourceMapServer
+  def initialize sprockets
+    @sprockets = sprockets
+  end
+
+  attr_reader :sprockets
+
+  attr_writer :prefix
+
+  def prefix
+    @prefix ||= '/__opal_source_maps__'
+  end
+
+  def inspect
+    "#<#{self.class}:#{object_id}>"
+  end
+
+  def call(env)
+    path_info = env['PATH_INFO']
+
+    if path_info =~ /\.js\.map$/
+      path   = env['PATH_INFO'].gsub(/^\/|\.js\.map$/, '')
+      asset  = sprockets[path]
+      return [404, {}, []] if asset.nil?
+
+      return [200, {"Content-Type" => "text/json"}, [$OPAL_SOURCE_MAPS[asset.pathname].to_s]]
+    else
+      return [200, {"Content-Type" => "text/text"}, [File.read(sprockets.resolve(path_info))]]
+    end
+  end
+end

data/lib/volt/server/template_parser.rb

@@ -0,0 +1,452 @@
+require 'volt/server/scope'
+require 'volt/server/if_binding_setup'
+require 'nokogiri'
+
+# TODO: The section_name that we're passing in should probably be
+# abstracted out.  Possibly this whole thing needs a rewrite.
+
+class Template
+	attr_accessor :current_scope, :section_name
+
+	def initialize(template_parser, section_name, template, scope=Scope.new)
+    @binding_number = 0
+
+		@template_parser = template_parser
+    @section_name = section_name
+		@template = template
+    @scopes = [scope]
+    @current_scope = @scopes.first
+	end
+
+	def html
+    if @template.respond_to?(:name) && @template.name[0] == ':'
+      # Don't return the <:section> tags
+      return @template.children.to_html
+    else
+      # if @template.class == Nokogiri::XML::NodeSet
+      #   result = ''
+      #   @template.each do |node|
+      #     result << node.to_html
+      #   end
+      # else
+    		result = @template.to_html
+      # end
+      result
+    end
+	end
+
+
+	def add_binding(node, content)
+		if content[0] == '/'
+			add_close_mustache(node)
+		elsif content[0] == '#'
+			command, *content = content.split(/ /)
+			content = content.join(' ')
+
+			case command
+		  when '#template'
+		    return add_template(node, content)
+			when '#each'
+				return add_each_binding(node, content)
+			when '#if'
+				return add_if_binding(node, content)
+      when '#elsif'
+        return add_else_binding(node, content)
+      when '#else'
+        if content.present?
+          # TODO: improve error, include line/file
+          raise "#else should not include a condition, use #elsif instead.  #{content} was passed as a condition."
+        end
+        
+        return add_else_binding(node, nil)
+			else
+				# TODO: Handle invalid command
+				raise "Invalid Command"
+			end
+		else
+			# text binding
+			return add_text_binding(content)
+		end
+	end
+
+	def add_template(node, content)
+		html = "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
+
+		@current_scope.add_binding(@binding_number, "lambda { |target, context, id| TemplateBinding.new(target, context, id, #{@template_parser.template_path.inspect}, Proc.new { [#{content}] }) }")
+
+		@binding_number += 1
+		return html
+	end
+
+	def add_each_binding(node, content)
+		html = "<!-- $#{@binding_number} -->"
+    
+    content, variable_name = content.strip.split(/ as /)
+
+    template_name = "#{@template_parser.template_path}/#{section_name}/__template/#{@binding_number}"
+		@current_scope.add_binding(@binding_number, "lambda { |target, context, id| EachBinding.new(target, context, id, Proc.new { #{content} }, #{variable_name.inspect}, #{template_name.inspect}) }")
+
+		# Add the node, the binding number, then store the location where the
+		# bindings for this block starts.
+		@current_scope = Scope.new(@binding_number)
+		@scopes << @current_scope
+
+		@binding_number += 1
+		return html
+	end
+
+	def add_if_binding(node, content)
+		html = "<!-- $#{@binding_number} -->"
+
+    template_name = "#{@template_parser.template_path}/#{section_name}/__template/#{@binding_number}"
+    if_binding_setup = IfBindingSetup.new
+    if_binding_setup.add_branch(content, template_name)
+    
+		@current_scope.start_if_binding(@binding_number, if_binding_setup)
+
+		# Add the node, the binding number, then store the location where the
+		# bindings for this block starts.
+		@current_scope = Scope.new(@binding_number)
+		@scopes << @current_scope
+
+		@binding_number += 1
+		return html
+	end
+  
+  def add_else_binding(node, content)
+    html = add_close_mustache(node, false)
+    
+		html += "<!-- $#{@binding_number} -->"
+    template_name = "#{@template_parser.template_path}/#{section_name}/__template/#{@binding_number}"
+    
+    @current_scope.current_if_binding[1].add_branch(content, template_name)
+    
+		# Add the node, the binding number, then store the location where the
+		# bindings for this block starts.
+		@current_scope = Scope.new(@binding_number)
+		@scopes << @current_scope
+
+		@binding_number += 1
+    
+    return html
+  end
+
+	def add_close_mustache(node, close_if=true)
+		scope = @scopes.pop
+		@current_scope = @scopes.last
+    
+    # Close an outstanding if binding (if it exists)
+    @current_scope.close_if_binding! if close_if
+    
+		# Track that this scope was closed out
+		@current_scope.add_closed_child_scope(scope)
+
+		html = "<!-- $/#{scope.outer_binding_number} -->"
+
+		return html
+	end
+
+	# When we find a binding, we pass it's content in here and replace it with
+	# the return value
+	def add_text_binding(content)
+		html = "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
+
+		@current_scope.add_binding(@binding_number, "lambda { |target, context, id| ContentBinding.new(target, context, id, Proc.new { #{content} }) }")
+
+		@binding_number += 1
+		return html
+	end
+
+  def setup_node_id(node)
+    id = node['id']
+		# First assign this node an id if it doesn't have one
+		unless id
+			id = node['id'] = "id#{@binding_number}"
+			@binding_number += 1
+		end
+  end
+
+  # Attribute bindings support multiple handlebar listeners
+  # Exvoltle:
+  #    <button click="{_primary} {_important}">...
+  #
+  # To accomplish this, we create a new listener from the existing ones in the Proc
+  # that we pass to the binding when it is created.
+	def add_attribute_binding(node, attribute, content)
+		setup_node_id(node)
+    
+    if content =~ /^\{[^\{]+\}$/
+      # Getter is the content inside of { ... }
+      add_single_getter(node, attribute, content)
+    else
+      add_multiple_getters(node, attribute, content)
+    end
+
+	end
+  
+  def add_single_getter(node, attribute, content)
+    if attribute == 'checked' || true
+      # For a checkbox, we don't want to add
+      getter = content[1..-2]
+    else
+      # Otherwise we should combine them
+      # TODO: We should make .or handle assignment
+      getter = "_tmp = #{content[1..-2]}.or('') ; _tmp.reactive_manager.setter! { |val| self.#{content[1..-2]} = val } ; _tmp"
+    end
+    
+    @current_scope.add_binding(node['id'], "lambda { |target, context, id| AttributeBinding.new(target, context, id, #{attribute.inspect}, Proc.new { #{getter} }) }")
+  end
+  
+  def add_multiple_getters(node, attribute, content)
+    case attribute
+    when 'checked', 'value'
+      if parts.size > 1
+        # Multiple ReactiveValue's can not be passed to value or checked attributes.
+        raise "Multiple bindings can not be passed to a #{attribute} binding."
+      end
+    end
+    
+    reactive_template_path = add_reactive_template(content)
+    
+    @current_scope.add_binding(node['id'], "lambda { |target, context, id| AttributeBinding.new(target, context, id, #{attribute.inspect}, Proc.new { ReactiveTemplate.new(context, #{reactive_template_path.inspect}) }) }")
+  end
+  
+  # Returns a path to a template for the content.  This can be passed
+  # into ReactiveTemplate.new, along with the current context.
+  def add_reactive_template(content)
+    # Return a template path instead
+    template_name = "__attribute/#{@binding_number}"
+    full_template_path = "#{@template_parser.template_path}/#{section_name}/#{template_name}"
+    @binding_number += 1
+  
+    attribute_template = Template.new(@template_parser, section_name, Nokogiri::HTML::DocumentFragment.parse(content))
+    @template_parser.add_template("#{section_name}/#{template_name}", attribute_template)
+    attribute_template.start_walk
+    attribute_template.pull_closed_block_scopes
+
+    return full_template_path
+  end
+
+	def add_event_binding(node, attribute_name, content)
+    setup_node_id(node)
+    
+    event = attribute_name[2..-1]
+    
+    if node.name == 'a'
+      # For links, we need to add blank href to make it clickable.
+      node['href'] ||= ''
+    end
+
+    @current_scope.add_binding(node['id'], "lambda { |target, context, id| EventBinding.new(target, context, id, #{event.inspect}, Proc.new {|event| #{content} })}")
+  end
+
+	def pull_closed_block_scopes(scope=@current_scope)
+    if scope.closed_block_scopes
+      scope.closed_block_scopes.each do |sub_scope|
+        # Loop through any subscopes first, pull them in.
+        pull_closed_block_scopes(sub_scope)
+        
+        # Grab everything between the start/end html comments
+        start_node = find_by_comment("$#{sub_scope.outer_binding_number}")
+        end_node = find_by_comment("$/#{sub_scope.outer_binding_number}")
+
+        move_nodes_to_new_template(start_node, end_node, sub_scope)
+      end
+    end
+  end
+
+
+	def move_nodes_to_new_template(start_node, end_node, scope)
+    # TODO: currently this doesn't handle spanning nodes within seperate containers.
+    # so doing tr's doesn't work for some reason.
+    
+		start_parent = start_node.parent
+		start_parent = start_parent.children if start_parent.is_a?(Nokogiri::HTML::DocumentFragment) || start_parent.is_a?(Nokogiri::XML::Element)
+		start_index = start_parent.index(start_node) + 1
+
+		end_parent = end_node.parent
+		end_parent = end_parent.children if end_parent.is_a?(Nokogiri::HTML::DocumentFragment) || end_parent.is_a?(Nokogiri::XML::Element)
+		end_index = end_parent.index(end_node) - 1
+
+		move_nodes = start_parent[start_index..end_index]
+		move_nodes.remove
+
+    new_template = Template.new(@template_parser, section_name, move_nodes, scope)
+    
+    @template_parser.add_template("#{section_name}/__template/#{scope.outer_binding_number}", new_template)
+	end
+
+
+  def find_by_comment(name)
+    return @template.xpath("descendant::comment()[. = ' #{name} ']").first
+  end
+
+	def start_walk
+		walk(@template)
+	end
+
+	# We implement a dom walker that can walk down the dom and spit out output
+	# html as we go
+	def walk(node)
+		case node.type
+		when 1
+			# html node
+      walk_html_node(node)
+		when 3
+			# text node
+      walk_text_node(node)
+		end
+
+		node.children.each do |child|
+			walk(child)
+		end
+	end
+  
+  def walk_html_node(node)
+    if node.name[0] == ':' && node.path.count('/') > 1
+      parse_component(node)
+    elsif node.name == 'textarea'
+      parse_textarea(node)
+    else
+      parse_html_node(node)
+    end
+  end
+  
+  # We provide a quick way to render components with tags starting
+  # with a :
+  # Count the number of /'s in the path, if we are at the root node
+  # we can ignore it, since this is the template its self.
+  # TODO: Root node might not be the template if we parsed directly 
+  # without a subtemplate specifier.  We need to find a good way to
+  # parse only within the subtemplate.
+  def parse_component(node)
+    template_path = node.name[1..-1].gsub(':', '/')
+
+    # Take the attributes and turn them into a hash
+    attribute_hash = {}
+    node.attribute_nodes.each do |attribute_node|
+      content = attribute_node.value
+      
+      if !content.index('{')
+        # passing in a string
+        value = content.inspect
+      elsif content =~ /^\{[^\}]+\}$/
+        # Has one binding, just get it
+        value = "Proc.new { #{content[1..-2]} }"
+      else
+        # Has multiple bindings, we need to render a template here
+        attr_template_path = add_reactive_template(content)
+        
+        value = "Proc.new { ReactiveTemplate.new(context, #{attr_template_path.inspect}) }"
+      end
+      
+      attribute_hash[attribute_node.name] = value
+    end
+    
+    attributes_string = attribute_hash.to_a.map do |key, value|
+      "#{key.inspect} => #{value}"
+    end.join(', ')
+
+    # Setup the arguments string, which goes to the TemplateBinding
+    args_str = "#{template_path.inspect}"
+    args_str << ", {#{attributes_string}}" if attribute_hash.size > 0
+
+		new_html = add_template(node, args_str)
+    
+    node.swap(new_html)#Nokogiri::HTML::DocumentFragment.parse(new_html))
+  end
+  
+  def parse_textarea(node)
+    # The contents of textareas should really be treated like a 
+    # value= attribute.  So here we pull the content into a value attribute
+    # if the textarea has bindings in the content.
+    if node.inner_html =~ /\{[^\}]+\}/
+      node[:value] = node.inner_html
+      node.children.remove
+    end
+    
+    parse_html_node(node)
+  end
+  
+  def parse_html_node(node)
+		node.attribute_nodes.each do |attribute_node|
+		  if attribute_node.name =~ /^e\-/
+        # We have an e- binding
+        add_event_binding(node, attribute_node.name, attribute_node.value)
+
+        # remove the attribute
+        attribute_node.remove
+			elsif attribute_node.value.match(/\{[^\}]+\}/)
+        # Has bindings
+				add_attribute_binding(node, attribute_node.name, attribute_node.value)
+
+				# remove the attribute
+				attribute_node.remove
+			end
+		end    
+  end
+  
+  def walk_text_node(node)
+		new_html = node.content.gsub(/\{([^\}]+)\}/) do |template_binding|
+			add_binding(node, $1)
+		end
+
+    # puts "------! #{new_html.inspect} - #{node.class.inspect} - #{node.inspect}"
+
+    # TODO: Broke here in jruby
+    node.swap(new_html)# if new_html.blank?
+    
+    #Nokogiri::HTML::DocumentFragment.parse(new_html))
+  end
+end
+
+class TemplateParser
+	attr_accessor :dom, :bindings, :template_path
+
+	def initialize(template, template_path)
+		@templates = {}
+    @template_path = template_path
+
+    template_fragment = Nokogiri::HTML::DocumentFragment.parse(template)
+
+    # Add templates for each section
+    
+    # Check for sections
+    sections = []
+    if template_fragment.children[0].name[0] == ':'
+      template_fragment.children.each do |child|
+        if child.is_a?(Nokogiri::XML::Element)
+          sections << [child, child.name[1..-1]]
+        end
+      end
+    else
+      sections << [template_fragment, 'body']
+    end
+    
+    sections.each do |section, name|
+  		template = Template.new(self, name, section)
+  		add_template(name, template)
+  		template.start_walk
+  		template.pull_closed_block_scopes
+    end
+
+	end
+
+	def add_template(name, template)
+		@templates[@template_path + '/' + name] = template
+	end
+
+	# Return the templates, but map the html from nokogiri to html
+	def templates
+		mapped = {}
+		@templates.each_pair do |name, template|
+			mapped[name] = {
+				'html' => template.html,
+				'bindings' => template.current_scope.bindings
+			}
+		end
+
+		return mapped
+	end
+
+end