You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@deltacloud.apache.org by lu...@apache.org on 2010/07/09 01:14:21 UTC
svn commit: r961978 [8/13] - in /incubator/deltacloud/trunk/framework: ./
app/ app/controllers/ app/helpers/ app/models/ app/views/
app/views/accounts/ app/views/credentials/ app/views/images/
app/views/instances/ app/views/layouts/ app/views/root/ con...
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/precompiler.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/precompiler.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/precompiler.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/precompiler.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,997 @@
+require 'strscan'
+require 'haml/shared'
+
+module Haml
+ # Handles the internal pre-compilation from Haml into Ruby code,
+ # which then runs the final creation of the HTML string.
+ module Precompiler
+ include Haml::Util
+
+ # Designates an XHTML/XML element.
+ ELEMENT = ?%
+
+ # Designates a <tt><div></tt> element with the given class.
+ DIV_CLASS = ?.
+
+ # Designates a <tt><div></tt> element with the given id.
+ DIV_ID = ?#
+
+ # Designates an XHTML/XML comment.
+ COMMENT = ?/
+
+ # Designates an XHTML doctype or script that is never HTML-escaped.
+ DOCTYPE = ?!
+
+ # Designates script, the result of which is output.
+ SCRIPT = ?=
+
+ # Designates script that is always HTML-escaped.
+ SANITIZE = ?&
+
+ # Designates script, the result of which is flattened and output.
+ FLAT_SCRIPT = ?~
+
+ # Designates script which is run but not output.
+ SILENT_SCRIPT = ?-
+
+ # When following SILENT_SCRIPT, designates a comment that is not output.
+ SILENT_COMMENT = ?#
+
+ # Designates a non-parsed line.
+ ESCAPE = ?\\
+
+ # Designates a block of filtered text.
+ FILTER = ?:
+
+ # Designates a non-parsed line. Not actually a character.
+ PLAIN_TEXT = -1
+
+ # Keeps track of the ASCII values of the characters that begin a
+ # specially-interpreted line.
+ SPECIAL_CHARACTERS = [
+ ELEMENT,
+ DIV_CLASS,
+ DIV_ID,
+ COMMENT,
+ DOCTYPE,
+ SCRIPT,
+ SANITIZE,
+ FLAT_SCRIPT,
+ SILENT_SCRIPT,
+ ESCAPE,
+ FILTER
+ ]
+
+ # The value of the character that designates that a line is part
+ # of a multiline string.
+ MULTILINE_CHAR_VALUE = ?|
+
+ # Regex to match keywords that appear in the middle of a Ruby block
+ # with lowered indentation.
+ # If a block has been started using indentation,
+ # lowering the indentation with one of these won't end the block.
+ # For example:
+ #
+ # - if foo
+ # %p yes!
+ # - else
+ # %p no!
+ #
+ # The block is ended after <tt>%p no!</tt>, because <tt>else</tt>
+ # is a member of this array.
+ MID_BLOCK_KEYWORD_REGEX = /-\s*(#{%w[else elsif rescue ensure when end].join('|')})\b/
+
+ # The Regex that matches a Doctype command.
+ DOCTYPE_REGEX = /(\d\.\d)?[\s]*([a-z]*)/i
+
+ # The Regex that matches a literal string or symbol value
+ LITERAL_VALUE_REGEX = /:(\w*)|(["'])([^\\#'"]|\\.)*\2/
+
+ private
+
+ # Returns the precompiled string with the preamble and postamble
+ def precompiled_with_ambles(local_names)
+ preamble = <<END.gsub("\n", ";")
+extend Haml::Helpers
+_hamlout = @haml_buffer = Haml::Buffer.new(@haml_buffer, #{options_for_buffer.inspect})
+_erbout = _hamlout.buffer
+__in_erb_template = true
+END
+ postamble = <<END.gsub("\n", ";")
+@haml_buffer = @haml_buffer.upper
+_erbout
+END
+ preamble + locals_code(local_names) + precompiled + postamble
+ end
+
+ def locals_code(names)
+ names = names.keys if Hash == names
+
+ names.map do |name|
+ # Can't use || because someone might explicitly pass in false with a symbol
+ sym_local = "_haml_locals[#{name.to_sym.inspect}]"
+ str_local = "_haml_locals[#{name.to_s.inspect}]"
+ "#{name} = #{sym_local}.nil? ? #{str_local} : #{sym_local}"
+ end.join(';') + ';'
+ end
+
+ class Line < Struct.new(:text, :unstripped, :full, :index, :precompiler, :eod)
+ alias_method :eod?, :eod
+
+ def tabs
+ line = self
+ @tabs ||= precompiler.instance_eval do
+ break 0 if line.text.empty? || !(whitespace = line.full[/^\s+/])
+
+ if @indentation.nil?
+ @indentation = whitespace
+
+ if @indentation.include?(?\s) && @indentation.include?(?\t)
+ raise SyntaxError.new("Indentation can't use both tabs and spaces.", line.index)
+ end
+
+ @flat_spaces = @indentation * @template_tabs if flat?
+ break 1
+ end
+
+ tabs = whitespace.length / @indentation.length
+ break tabs if whitespace == @indentation * tabs
+ break @template_tabs if flat? && whitespace =~ /^#{@indentation * @template_tabs}/
+
+ raise SyntaxError.new(<<END.strip.gsub("\n", ' '), line.index)
+Inconsistent indentation: #{Haml::Shared.human_indentation whitespace, true} used for indentation,
+but the rest of the document was indented using #{Haml::Shared.human_indentation @indentation}.
+END
+ end
+ end
+ end
+
+ def precompile
+ @haml_comment = @dont_indent_next_line = @dont_tab_up_next_text = false
+ @indentation = nil
+ @line = next_line
+ resolve_newlines
+ newline
+
+ raise SyntaxError.new("Indenting at the beginning of the document is illegal.", @line.index) if @line.tabs != 0
+
+ while next_line
+ process_indent(@line) unless @line.text.empty?
+
+ if flat?
+ push_flat(@line)
+ @line = @next_line
+ newline
+ next
+ end
+
+ process_line(@line.text, @line.index) unless @line.text.empty? || @haml_comment
+
+ if !flat? && @next_line.tabs - @line.tabs > 1
+ raise SyntaxError.new("The line was indented #{@next_line.tabs - @line.tabs} levels deeper than the previous line.", @next_line.index)
+ end
+
+ resolve_newlines unless @next_line.eod?
+ @line = @next_line
+ newline unless @next_line.eod?
+ end
+
+ # Close all the open tags
+ close until @to_close_stack.empty?
+ flush_merged_text
+ end
+
+ # Processes and deals with lowering indentation.
+ def process_indent(line)
+ return unless line.tabs <= @template_tabs && @template_tabs > 0
+
+ to_close = @template_tabs - line.tabs
+ to_close.times { |i| close unless to_close - 1 - i == 0 && mid_block_keyword?(line.text) }
+ end
+
+ # Processes a single line of Haml.
+ #
+ # This method doesn't return anything; it simply processes the line and
+ # adds the appropriate code to <tt>@precompiled</tt>.
+ def process_line(text, index)
+ @index = index + 1
+
+ case text[0]
+ when DIV_CLASS; render_div(text)
+ when DIV_ID
+ return push_plain(text) if text[1] == ?{
+ render_div(text)
+ when ELEMENT; render_tag(text)
+ when COMMENT; render_comment(text[1..-1].strip)
+ when SANITIZE
+ return push_plain(text[3..-1].strip, :escape_html => true) if text[1..2] == "=="
+ return push_script(text[2..-1].strip, :escape_html => true) if text[1] == SCRIPT
+ return push_flat_script(text[2..-1].strip, :escape_html => true) if text[1] == FLAT_SCRIPT
+ return push_plain(text[1..-1].strip, :escape_html => true) if text[1] == ?\s
+ push_plain text
+ when SCRIPT
+ return push_plain(text[2..-1].strip) if text[1] == SCRIPT
+ push_script(text[1..-1])
+ when FLAT_SCRIPT; push_flat_script(text[1..-1])
+ when SILENT_SCRIPT
+ return start_haml_comment if text[1] == SILENT_COMMENT
+
+ raise SyntaxError.new(<<END.rstrip, index) if text[1..-1].strip == "end"
+You don't need to use "- end" in Haml. Use indentation instead:
+- if foo?
+ %strong Foo!
+- else
+ Not foo.
+END
+
+ push_silent(text[1..-1], true)
+ newline_now
+
+ # Handle stuff like - end.join("|")
+ @to_close_stack.first << false if text =~ /-\s*end\b/ && !block_opened?
+
+ case_stmt = text =~ /-\s*case\b/
+ block = block_opened? && !mid_block_keyword?(text)
+ push_and_tabulate([:script]) if block || case_stmt
+ push_and_tabulate(:nil) if block && case_stmt
+ when FILTER; start_filtered(text[1..-1].downcase)
+ when DOCTYPE
+ return render_doctype(text) if text[0...3] == '!!!'
+ return push_plain(text[3..-1].strip, :escape_html => false) if text[1..2] == "=="
+ return push_script(text[2..-1].strip, :escape_html => false) if text[1] == SCRIPT
+ return push_flat_script(text[2..-1].strip, :escape_html => false) if text[1] == FLAT_SCRIPT
+ return push_plain(text[1..-1].strip, :escape_html => false) if text[1] == ?\s
+ push_plain text
+ when ESCAPE; push_plain text[1..-1]
+ else push_plain text
+ end
+ end
+
+ # Returns whether or not the text is a silent script text with one
+ # of Ruby's mid-block keywords.
+ def mid_block_keyword?(text)
+ MID_BLOCK_KEYWORD_REGEX =~ text
+ end
+
+ # Evaluates <tt>text</tt> in the context of the scope object, but
+ # does not output the result.
+ def push_silent(text, can_suppress = false)
+ flush_merged_text
+ return if can_suppress && options[:suppress_eval]
+ @precompiled << "#{text};"
+ end
+
+ # Adds <tt>text</tt> to <tt>@buffer</tt> with appropriate tabulation
+ # without parsing it.
+ def push_merged_text(text, tab_change = 0, indent = true)
+ text = !indent || @dont_indent_next_line || @options[:ugly] ? text : "#{' ' * @output_tabs}#{text}"
+ @to_merge << [:text, text, tab_change]
+ @dont_indent_next_line = false
+ end
+
+ # Concatenate <tt>text</tt> to <tt>@buffer</tt> without tabulation.
+ def concat_merged_text(text)
+ @to_merge << [:text, text, 0]
+ end
+
+ def push_text(text, tab_change = 0)
+ push_merged_text("#{text}\n", tab_change)
+ end
+
+ def flush_merged_text
+ return if @to_merge.empty?
+
+ text, tab_change = @to_merge.inject(["", 0]) do |(str, mtabs), (type, val, tabs)|
+ case type
+ when :text
+ [str << val.inspect[1...-1], mtabs + tabs]
+ when :script
+ if mtabs != 0 && !@options[:ugly]
+ val = "_hamlout.adjust_tabs(#{mtabs}); " + val
+ end
+ [str << "\#{#{val}}", 0]
+ else
+ raise SyntaxError.new("[HAML BUG] Undefined entry in Haml::Precompiler@to_merge.")
+ end
+ end
+
+ @precompiled <<
+ if @options[:ugly]
+ "_erbout << \"#{text}\";"
+ else
+ "_hamlout.push_text(\"#{text}\", #{tab_change}, #{@dont_tab_up_next_text.inspect});"
+ end
+ @to_merge = []
+ @dont_tab_up_next_text = false
+ end
+
+ # Renders a block of text as plain text.
+ # Also checks for an illegally opened block.
+ def push_plain(text, options = {})
+ if block_opened?
+ raise SyntaxError.new("Illegal nesting: nesting within plain text is illegal.", @next_line.index)
+ end
+
+ if contains_interpolation?(text)
+ push_script unescape_interpolation(text), :escape_html => options[:escape_html]
+ else
+ push_text text
+ end
+ end
+
+ # Adds +text+ to <tt>@buffer</tt> while flattening text.
+ def push_flat(line)
+ text = line.full.dup
+ text = "" unless text.gsub!(/^#{@flat_spaces}/, '')
+ @filter_buffer << "#{text}\n"
+ end
+
+ # Causes <tt>text</tt> to be evaluated in the context of
+ # the scope object and the result to be added to <tt>@buffer</tt>.
+ #
+ # If <tt>opts[:preserve_script]</tt> is true, Haml::Helpers#find_and_flatten is run on
+ # the result before it is added to <tt>@buffer</tt>
+ def push_script(text, opts = {})
+ raise SyntaxError.new("There's no Ruby code for = to evaluate.") if text.empty?
+ return if options[:suppress_eval]
+ opts[:escape_html] = options[:escape_html] if opts[:escape_html].nil?
+
+ args = %w[preserve_script in_tag preserve_tag escape_html nuke_inner_whitespace]
+ args.map! {|name| opts[name.to_sym]}
+ args << !block_opened? << @options[:ugly]
+
+ no_format = @options[:ugly] &&
+ !(opts[:preserve_script] || opts[:preserve_tag] || opts[:escape_html])
+ output_temp = "(haml_very_temp = haml_temp; haml_temp = nil; haml_very_temp)"
+ out = "_hamlout.#{static_method_name(:format_script, *args)}(#{output_temp});"
+
+ # Prerender tabulation unless we're in a tag
+ push_merged_text '' unless opts[:in_tag]
+
+ unless block_opened?
+ @to_merge << [:script, no_format ? "#{text}\n" : "haml_temp = #{text}\n#{out}"]
+ concat_merged_text("\n") unless opts[:in_tag] || opts[:nuke_inner_whitespace]
+ @newlines -= 1
+ return
+ end
+
+ flush_merged_text
+
+ push_silent "haml_temp = #{text}"
+ newline_now
+ push_and_tabulate([:loud, "_erbout << #{no_format ? "#{output_temp}.to_s;" : out}",
+ !(opts[:in_tag] || opts[:nuke_inner_whitespace] || @options[:ugly])])
+ end
+
+ # Causes <tt>text</tt> to be evaluated, and Haml::Helpers#find_and_flatten
+ # to be run on it afterwards.
+ def push_flat_script(text, options = {})
+ flush_merged_text
+
+ raise SyntaxError.new("There's no Ruby code for ~ to evaluate.") if text.empty?
+ push_script(text, options.merge(:preserve_script => true))
+ end
+
+ def start_haml_comment
+ return unless block_opened?
+
+ @haml_comment = true
+ push_and_tabulate([:haml_comment])
+ end
+
+ # Closes the most recent item in <tt>@to_close_stack</tt>.
+ def close
+ tag, *rest = @to_close_stack.pop
+ send("close_#{tag}", *rest)
+ end
+
+ # Puts a line in <tt>@precompiled</tt> that will add the closing tag of
+ # the most recently opened tag.
+ def close_element(value)
+ tag, nuke_outer_whitespace, nuke_inner_whitespace = value
+ @output_tabs -= 1 unless nuke_inner_whitespace
+ @template_tabs -= 1
+ rstrip_buffer! if nuke_inner_whitespace
+ push_merged_text("</#{tag}>" + (nuke_outer_whitespace ? "" : "\n"),
+ nuke_inner_whitespace ? 0 : -1, !nuke_inner_whitespace)
+ @dont_indent_next_line = nuke_outer_whitespace
+ end
+
+ # Closes a Ruby block.
+ def close_script
+ push_silent "end", true
+ @template_tabs -= 1
+ end
+
+ # Closes a comment.
+ def close_comment(has_conditional)
+ @output_tabs -= 1
+ @template_tabs -= 1
+ close_tag = has_conditional ? "<![endif]-->" : "-->"
+ push_text(close_tag, -1)
+ end
+
+ # Closes a loud Ruby block.
+ def close_loud(command, add_newline, push_end = true)
+ push_silent('end', true) if push_end
+ @precompiled << command
+ @template_tabs -= 1
+ concat_merged_text("\n") if add_newline
+ end
+
+ # Closes a filtered block.
+ def close_filtered(filter)
+ filter.internal_compile(self, @filter_buffer)
+ @flat = false
+ @flat_spaces = nil
+ @filter_buffer = nil
+ @template_tabs -= 1
+ end
+
+ def close_haml_comment
+ @haml_comment = false
+ @template_tabs -= 1
+ end
+
+ def close_nil
+ @template_tabs -= 1
+ end
+
+ # Iterates through the classes and ids supplied through <tt>.</tt>
+ # and <tt>#</tt> syntax, and returns a hash with them as attributes,
+ # that can then be merged with another attributes hash.
+ def parse_class_and_id(list)
+ attributes = {}
+ list.scan(/([#.])([-_a-zA-Z0-9]+)/) do |type, property|
+ case type
+ when '.'
+ if attributes['class']
+ attributes['class'] += " "
+ else
+ attributes['class'] = ""
+ end
+ attributes['class'] += property
+ when '#'; attributes['id'] = property
+ end
+ end
+ attributes
+ end
+
+ def parse_static_hash(text)
+ attributes = {}
+ scanner = StringScanner.new(text)
+ scanner.scan(/\s+/)
+ until scanner.eos?
+ return unless key = scanner.scan(LITERAL_VALUE_REGEX)
+ return unless scanner.scan(/\s*=>\s*/)
+ return unless value = scanner.scan(LITERAL_VALUE_REGEX)
+ attributes[eval(key).to_s] = eval(value).to_s
+ scanner.scan(/[,\s]*/)
+ end
+ text.count("\n").times { newline }
+ attributes
+ end
+
+ # This is a class method so it can be accessed from Buffer.
+ def self.build_attributes(is_html, attr_wrapper, attributes = {})
+ quote_escape = attr_wrapper == '"' ? """ : "'"
+ other_quote_char = attr_wrapper == '"' ? "'" : '"'
+
+ result = attributes.collect do |attr, value|
+ next if value.nil?
+
+ if value == true
+ next " #{attr}" if is_html
+ next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}"
+ elsif value == false
+ next
+ end
+
+ value = Haml::Helpers.preserve(Haml::Helpers.escape_once(value.to_s))
+ # We want to decide whether or not to escape quotes
+ value.gsub!('"', '"')
+ this_attr_wrapper = attr_wrapper
+ if value.include? attr_wrapper
+ if value.include? other_quote_char
+ value = value.gsub(attr_wrapper, quote_escape)
+ else
+ this_attr_wrapper = other_quote_char
+ end
+ end
+ " #{attr}=#{this_attr_wrapper}#{value}#{this_attr_wrapper}"
+ end
+ result.compact.sort.join
+ end
+
+ def prerender_tag(name, self_close, attributes)
+ attributes_string = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
+ "<#{name}#{attributes_string}#{self_close && xhtml? ? ' /' : ''}>"
+ end
+
+ # Parses a line into tag_name, attributes, attributes_hash, object_ref, action, value
+ def parse_tag(line)
+ raise SyntaxError.new("Invalid tag: \"#{line}\".") unless match = line.scan(/%([-:\w]+)([-\w\.\#]*)(.*)/)[0]
+ tag_name, attributes, rest = match
+ new_attributes_hash = old_attributes_hash = last_line = object_ref = nil
+ attributes_hashes = []
+ while rest
+ case rest[0]
+ when ?{
+ break if old_attributes_hash
+ old_attributes_hash, rest, last_line = parse_old_attributes(rest)
+ attributes_hashes << [:old, old_attributes_hash]
+ when ?(
+ break if new_attributes_hash
+ new_attributes_hash, rest, last_line = parse_new_attributes(rest)
+ attributes_hashes << [:new, new_attributes_hash]
+ when ?[
+ break if object_ref
+ object_ref, rest = balance(rest, ?[, ?])
+ else; break
+ end
+ end
+
+ if rest
+ nuke_whitespace, action, value = rest.scan(/(<>|><|[><])?([=\/\~&!])?(.*)?/)[0]
+ nuke_whitespace ||= ''
+ nuke_outer_whitespace = nuke_whitespace.include? '>'
+ nuke_inner_whitespace = nuke_whitespace.include? '<'
+ end
+
+ value = value.to_s.strip
+ [tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
+ nuke_inner_whitespace, action, value, last_line || @index]
+ end
+
+ def parse_old_attributes(line)
+ line = line.dup
+ last_line = @index
+
+ begin
+ attributes_hash, rest = balance(line, ?{, ?})
+ rescue SyntaxError => e
+ if line.strip[-1] == ?, && e.message == "Unbalanced brackets."
+ line << "\n" << @next_line.text
+ last_line += 1
+ next_line
+ retry
+ end
+
+ raise e
+ end
+
+ attributes_hash = attributes_hash[1...-1] if attributes_hash
+ return attributes_hash, rest, last_line
+ end
+
+ def parse_new_attributes(line)
+ line = line.dup
+ scanner = StringScanner.new(line)
+ last_line = @index
+ attributes = {}
+
+ scanner.scan(/\(\s*/)
+ loop do
+ name, value = parse_new_attribute(scanner)
+ break if name.nil?
+
+ if name == false
+ text = (Haml::Shared.balance(line, ?(, ?)) || [line]).first
+ raise Haml::SyntaxError.new("Invalid attribute list: #{text.inspect}.", last_line - 1)
+ end
+ attributes[name] = value
+ scanner.scan(/\s*/)
+
+ if scanner.eos?
+ line << " " << @next_line.text
+ last_line += 1
+ next_line
+ scanner.scan(/\s*/)
+ end
+ end
+
+ static_attributes = {}
+ dynamic_attributes = "{"
+ attributes.each do |name, (type, val)|
+ if type == :static
+ static_attributes[name] = val
+ else
+ dynamic_attributes << name.inspect << " => " << val << ","
+ end
+ end
+ dynamic_attributes << "}"
+ dynamic_attributes = nil if dynamic_attributes == "{}"
+
+ return [static_attributes, dynamic_attributes], scanner.rest, last_line
+ end
+
+ def parse_new_attribute(scanner)
+ unless name = scanner.scan(/[-:\w]+/)
+ return if scanner.scan(/\)/)
+ return false
+ end
+
+ scanner.scan(/\s*/)
+ return name, [:static, true] unless scanner.scan(/=/) #/end
+
+ scanner.scan(/\s*/)
+ unless quote = scanner.scan(/["']/)
+ return false unless var = scanner.scan(/(@@?|\$)?\w+/)
+ return name, [:dynamic, var]
+ end
+
+ re = /((?:\\.|\#[^{]|[^#{quote}\\#])*#?)(#{quote}|#\{)/
+ content = []
+ loop do
+ return false unless scanner.scan(re)
+ content << [:str, scanner[1].gsub(/\\(.)/, '\1')]
+ break if scanner[2] == quote
+ content << [:ruby, balance(scanner, ?{, ?}, 1).first[0...-1]]
+ end
+
+ return name, [:static, content.first[1]] if content.size == 1
+ return name, [:dynamic,
+ '"' + content.map {|(t, v)| t == :str ? v.inspect[1...-1] : "\#{#{v}}"}.join + '"']
+ end
+
+ # Parses a line that will render as an XHTML tag, and adds the code that will
+ # render that tag to <tt>@precompiled</tt>.
+ def render_tag(line)
+ tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
+ nuke_inner_whitespace, action, value, last_line = parse_tag(line)
+
+ raise SyntaxError.new("Illegal element: classes and ids must have values.") if attributes =~ /[\.#](\.|#|\z)/
+
+ # Get rid of whitespace outside of the tag if we need to
+ rstrip_buffer! if nuke_outer_whitespace
+
+ preserve_tag = options[:preserve].include?(tag_name)
+ nuke_inner_whitespace ||= preserve_tag
+ preserve_tag &&= !options[:ugly]
+
+ case action
+ when '/'; self_closing = true
+ when '~'; parse = preserve_script = true
+ when '='
+ parse = true
+ value = unescape_interpolation(value[1..-1].strip) if value[0] == ?=
+ when '&', '!'
+ if value[0] == ?= || value[0] == ?~
+ parse = true
+ preserve_script = (value[0] == ?~)
+ value =
+ if value[1] == ?=
+ unescape_interpolation(value[2..-1].strip)
+ else
+ value[1..-1].strip
+ end
+ elsif contains_interpolation?(value)
+ parse = true
+ value = unescape_interpolation(value)
+ end
+ else
+ if contains_interpolation?(value)
+ parse = true
+ value = unescape_interpolation(value)
+ end
+ end
+
+ if parse && @options[:suppress_eval]
+ parse = false
+ value = ''
+ end
+
+ escape_html = (action == '&' || (action != '!' && @options[:escape_html]))
+
+ object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
+
+ attributes = parse_class_and_id(attributes)
+ attributes_hashes.map! do |syntax, attributes_hash|
+ if syntax == :old
+ static_attributes = parse_static_hash(attributes_hash)
+ attributes_hash = nil if static_attributes || @options[:suppress_eval]
+ else
+ static_attributes, attributes_hash = attributes_hash
+ end
+ Buffer.merge_attrs(attributes, static_attributes) if static_attributes
+ attributes_hash
+ end.compact!
+
+ raise SyntaxError.new("Illegal nesting: nesting within a self-closing tag is illegal.", @next_line.index) if block_opened? && self_closing
+ raise SyntaxError.new("Illegal nesting: content can't be both given on the same line as %#{tag_name} and nested within it.", @next_line.index) if block_opened? && !value.empty?
+ raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.", last_line - 1) if parse && value.empty?
+ raise SyntaxError.new("Self-closing tags can't have content.", last_line - 1) if self_closing && !value.empty?
+
+ self_closing ||= !!( !block_opened? && value.empty? && @options[:autoclose].include?(tag_name) )
+
+ dont_indent_next_line =
+ (nuke_outer_whitespace && !block_opened?) ||
+ (nuke_inner_whitespace && block_opened?)
+
+ # Check if we can render the tag directly to text and not process it in the buffer
+ if object_ref == "nil" && attributes_hashes.empty? && !preserve_script
+ tag_closed = !block_opened? && !self_closing && !parse
+
+ open_tag = prerender_tag(tag_name, self_closing, attributes)
+ if tag_closed
+ open_tag << "#{value}</#{tag_name}>"
+ open_tag << "\n" unless nuke_outer_whitespace
+ else
+ open_tag << "\n" unless parse || nuke_inner_whitespace || (self_closing && nuke_outer_whitespace)
+ end
+
+ push_merged_text(open_tag, tag_closed || self_closing || nuke_inner_whitespace ? 0 : 1,
+ !nuke_outer_whitespace)
+
+ @dont_indent_next_line = dont_indent_next_line
+ return if tag_closed
+ else
+ flush_merged_text
+ content = value.empty? || parse ? 'nil' : value.dump
+ if attributes_hashes.empty?
+ attributes_hashes = ''
+ elsif attributes_hashes.size == 1
+ attributes_hashes = ", #{attributes_hashes.first}"
+ else
+ attributes_hashes = ", (#{attributes_hashes.join(").merge(")})"
+ end
+
+ args = [tag_name, self_closing, !block_opened?, preserve_tag, escape_html,
+ attributes, nuke_outer_whitespace, nuke_inner_whitespace
+ ].map { |v| v.inspect }.join(', ')
+ push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hashes})"
+ @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
+ end
+
+ return if self_closing
+
+ if value.empty?
+ push_and_tabulate([:element, [tag_name, nuke_outer_whitespace, nuke_inner_whitespace]])
+ @output_tabs += 1 unless nuke_inner_whitespace
+ return
+ end
+
+ if parse
+ push_script(value, :preserve_script => preserve_script, :in_tag => true,
+ :preserve_tag => preserve_tag, :escape_html => escape_html,
+ :nuke_inner_whitespace => nuke_inner_whitespace)
+ concat_merged_text("</#{tag_name}>" + (nuke_outer_whitespace ? "" : "\n"))
+ end
+ end
+
+ # Renders a line that creates an XHTML tag and has an implicit div because of
+ # <tt>.</tt> or <tt>#</tt>.
+ def render_div(line)
+ render_tag('%div' + line)
+ end
+
+ # Renders an XHTML comment.
+ def render_comment(line)
+ conditional, line = balance(line, ?[, ?]) if line[0] == ?[
+ line.strip!
+ conditional << ">" if conditional
+
+ if block_opened? && !line.empty?
+ raise SyntaxError.new('Illegal nesting: nesting within a tag that already has content is illegal.', @next_line.index)
+ end
+
+ open = "<!--#{conditional} "
+
+ # Render it statically if possible
+ unless line.empty?
+ return push_text("#{open}#{line} #{conditional ? "<![endif]-->" : "-->"}")
+ end
+
+ push_text(open, 1)
+ @output_tabs += 1
+ push_and_tabulate([:comment, !conditional.nil?])
+ unless line.empty?
+ push_text(line)
+ close
+ end
+ end
+
+ # Renders an XHTML doctype or XML shebang.
+ def render_doctype(line)
+ raise SyntaxError.new("Illegal nesting: nesting within a header command is illegal.", @next_line.index) if block_opened?
+ doctype = text_for_doctype(line)
+ push_text doctype if doctype
+ end
+
+ def text_for_doctype(text)
+ text = text[3..-1].lstrip.downcase
+ if text.index("xml") == 0
+ return nil if html?
+ wrapper = @options[:attr_wrapper]
+ return "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{text.split(' ')[1] || "utf-8"}#{wrapper} ?>"
+ end
+
+ if html5?
+ '<!DOCTYPE html>'
+ else
+ version, type = text.scan(DOCTYPE_REGEX)[0]
+
+ if xhtml?
+ if version == "1.1"
+ '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
+ else
+ case type
+ when "strict"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
+ when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
+ when "mobile"; '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">'
+ when "basic"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">'
+ else '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+ end
+ end
+
+ elsif html4?
+ case type
+ when "strict"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
+ when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
+ else '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
+ end
+ end
+ end
+ end
+
+ # Starts a filtered block.
+ def start_filtered(name)
+ raise Error.new("Invalid filter name \":#{name}\".") unless name =~ /^\w+$/
+ raise Error.new("Filter \"#{name}\" is not defined.") unless filter = Filters.defined[name]
+
+ push_and_tabulate([:filtered, filter])
+ @flat = true
+ @filter_buffer = String.new
+
+ # If we don't know the indentation by now, it'll be set in Line#tabs
+ @flat_spaces = @indentation * @template_tabs if @indentation
+ end
+
+ def raw_next_line
+ text = @template.shift
+ return unless text
+
+ index = @template_index
+ @template_index += 1
+
+ return text, index
+ end
+
+ def next_line
+ text, index = raw_next_line
+ return unless text
+
+ # :eod is a special end-of-document marker
+ line =
+ if text == :eod
+ Line.new '-#', '-#', '-#', index, self, true
+ else
+ Line.new text.strip, text.lstrip.chomp, text, index, self, false
+ end
+
+ # `flat?' here is a little outdated,
+ # so we have to manually check if either the previous or current line
+ # closes the flat block,
+ # as well as whether a new block is opened
+ @line.tabs if @line
+ unless (flat? && !closes_flat?(line) && !closes_flat?(@line)) ||
+ (@line && @line.text[0] == ?: && line.full =~ %r[^#{@line.full[/^\s+/]}\s])
+ if line.text.empty?
+ newline
+ return next_line
+ end
+
+ handle_multiline(line)
+ end
+
+ @next_line = line
+ end
+
+ def closes_flat?(line)
+ line && !line.text.empty? && line.full !~ /^#{@flat_spaces}/
+ end
+
+ def un_next_line(line)
+ @template.unshift line
+ @template_index -= 1
+ end
+
+ def handle_multiline(line)
+ if is_multiline?(line.text)
+ line.text.slice!(-1)
+ while new_line = raw_next_line.first
+ break if new_line == :eod
+ newline and next if new_line.strip.empty?
+ break unless is_multiline?(new_line.strip)
+ line.text << new_line.strip[0...-1]
+ newline
+ end
+ un_next_line new_line
+ resolve_newlines
+ end
+ end
+
+ # Checks whether or not +line+ is in a multiline sequence.
+ def is_multiline?(text)
+ text && text.length > 1 && text[-1] == MULTILINE_CHAR_VALUE && text[-2] == ?\s
+ end
+
+ def contains_interpolation?(str)
+ str.include?('#{')
+ end
+
+ def unescape_interpolation(str)
+ res = ''
+ rest = Haml::Shared.handle_interpolation str.dump do |scan|
+ escapes = (scan[2].size - 1) / 2
+ res << scan.matched[0...-3 - escapes]
+ if escapes % 2 == 1
+ res << '#{'
+ else
+ res << '#{' + eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"') + "}"# Use eval to get rid of string escapes
+ end
+ end
+ res + rest
+ end
+
+ def balance(*args)
+ res = Haml::Shared.balance(*args)
+ return res if res
+ raise SyntaxError.new("Unbalanced brackets.")
+ end
+
+ def block_opened?
+ !flat? && @next_line.tabs > @line.tabs
+ end
+
+ # Pushes value onto <tt>@to_close_stack</tt> and increases
+ # <tt>@template_tabs</tt>.
+ def push_and_tabulate(value)
+ @to_close_stack.push(value)
+ @template_tabs += 1
+ end
+
+ def flat?
+ @flat
+ end
+
+ def newline
+ @newlines += 1
+ end
+
+ def newline_now
+ @precompiled << "\n"
+ @newlines -= 1
+ end
+
+ def resolve_newlines
+ return unless @newlines > 0
+ @precompiled << "\n" * @newlines
+ @newlines = 0
+ end
+
+ # Get rid of and whitespace at the end of the buffer
+ # or the merged text
+ def rstrip_buffer!
+ if @to_merge.empty?
+ push_silent("_hamlout.rstrip!", false)
+ @dont_tab_up_next_text = true
+ return
+ end
+
+ last = @to_merge.last
+ case last.first
+ when :text
+ last[1].rstrip!
+ if last[1].empty?
+ @to_merge.pop
+ rstrip_buffer!
+ end
+ when :script
+ last[1].gsub!(/\(haml_temp, (.*?)\);$/, '(haml_temp.rstrip, \1);')
+ else
+ raise SyntaxError.new("[HAML BUG] Undefined entry in Haml::Precompiler@to_merge.")
+ end
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/shared.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/shared.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/shared.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/shared.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,78 @@
+require 'strscan'
+
+module Haml
+ # This module contains functionality that's shared between Haml and Sass.
+ module Shared
+ extend self
+
+ # Scans through a string looking for the interoplation-opening `#{`
+ # and, when it's found, yields the scanner to the calling code
+ # so it can handle it properly.
+ #
+ # The scanner will have any backslashes immediately in front of the `#{`
+ # as the second capture group (`scan[2]`),
+ # and the text prior to that as the first (`scan[1]`).
+ #
+ # @yieldparam scan [StringScanner] The scanner scanning through the string
+ # @return [String] The text remaining in the scanner after all `#{`s have been processed
+ def handle_interpolation(str)
+ scan = StringScanner.new(str)
+ yield scan while scan.scan(/(.*?)(\\*)\#\{/)
+ scan.rest
+ end
+
+ # Moves a scanner through a balanced pair of characters.
+ # For example:
+ #
+ # Foo (Bar (Baz bang) bop) (Bang (bop bip))
+ # ^ ^
+ # from to
+ #
+ # @param scanner [StringScanner] The string scanner to move
+ # @param start [Character] The character opening the balanced pair.
+ # A `Fixnum` in 1.8, a `String` in 1.9
+ # @param finish [Character] The character closing the balanced pair.
+ # A `Fixnum` in 1.8, a `String` in 1.9
+ # @param count [Fixnum] The number of opening characters matched
+ # before calling this method
+ # @return [(String, String)] The string matched within the balanced pair
+ # and the rest of the string.
+ # `["Foo (Bar (Baz bang) bop)", " (Bang (bop bip))"]` in the example above.
+ def balance(scanner, start, finish, count = 0)
+ str = ''
+ scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
+ regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
+ while scanner.scan(regexp)
+ str << scanner.matched
+ count += 1 if scanner.matched[-1] == start
+ count -= 1 if scanner.matched[-1] == finish
+ return [str.strip, scanner.rest] if count == 0
+ end
+ end
+
+ # Formats a string for use in error messages about indentation.
+ #
+ # @param indentation [String] The string used for indentation
+ # @param was [Boolean] Whether or not to add `"was"` or `"were"`
+ # (depending on how many characters were in `indentation`)
+ # @return [String] The name of the indentation (e.g. `"12 spaces"`, `"1 tab"`)
+ def human_indentation(indentation, was = false)
+ if !indentation.include?(?\t)
+ noun = 'space'
+ elsif !indentation.include?(?\s)
+ noun = 'tab'
+ else
+ return indentation.inspect + (was ? ' was' : '')
+ end
+
+ singular = indentation.length == 1
+ if was
+ was = singular ? ' was' : ' were'
+ else
+ was = ''
+ end
+
+ "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,51 @@
+require 'haml/engine'
+
+module Haml
+ # The class that keeps track of the global options for Haml within Rails.
+ module Template
+ extend self
+
+ @options = {}
+ # The options hash for Haml when used within Rails.
+ # See {file:HAML_REFERENCE.md#haml_options the Haml options documentation}.
+ #
+ # @return [Hash<Symbol, Object>]
+ attr_accessor :options
+ end
+end
+
+if defined?(RAILS_ENV) && RAILS_ENV == "production"
+ Haml::Template.options[:ugly] = true
+end
+
+# Decide how we want to load Haml into Rails.
+# Patching was necessary for versions <= 2.0.1,
+# but we can make it a normal handler for higher versions.
+if defined?(ActionView::TemplateHandler)
+ require 'haml/template/plugin'
+else
+ require 'haml/template/patch'
+end
+
+if defined?(RAILS_ROOT)
+ # Update init.rb to the current version
+ # if it's out of date.
+ #
+ # We can probably remove this as of v1.9,
+ # because the new init file is sufficiently flexible
+ # to not need updating.
+ rails_init_file = File.join(RAILS_ROOT, 'vendor', 'plugins', 'haml', 'init.rb')
+ haml_init_file = Haml::Util.scope('init.rb')
+ begin
+ if File.exists?(rails_init_file)
+ require 'fileutils'
+ FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
+ end
+ rescue SystemCallError
+ warn <<END
+HAML WARNING:
+#{rails_init_file} is out of date and couldn't be automatically updated.
+Please run `haml --rails #{File.expand_path(RAILS_ROOT)}' to update it.
+END
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/patch.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/patch.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/patch.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/patch.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,58 @@
+# This file makes Haml work with Rails
+# by monkeypatching the core template-compilation methods.
+# This is necessary for versions <= 2.0.1 because the template handler API
+# wasn't sufficiently powerful to deal with caching and so forth.
+
+# This module refers to the ActionView module that's part of Ruby on Rails.
+# Haml can be used as an alternate templating engine for it,
+# and includes several modifications to make it more Haml-friendly.
+# The documentation can be found
+# here[http://rubyonrails.org/api/classes/ActionView/Base.html].
+module ActionView
+ class Base
+ def delegate_template_exists_with_haml(template_path)
+ template_exists?(template_path, :haml) && [:haml]
+ end
+ alias_method :delegate_template_exists_without_haml, :delegate_template_exists?
+ alias_method :delegate_template_exists?, :delegate_template_exists_with_haml
+
+ def compile_template_with_haml(extension, template, file_name, local_assigns)
+ return compile_haml(template, file_name, local_assigns) if extension.to_s == "haml"
+ compile_template_without_haml(extension, template, file_name, local_assigns)
+ end
+ alias_method :compile_template_without_haml, :compile_template
+ alias_method :compile_template, :compile_template_with_haml
+
+ def compile_haml(template, file_name, local_assigns)
+ render_symbol = assign_method_name(:haml, template, file_name)
+ locals = local_assigns.keys
+
+ @@template_args[render_symbol] ||= {}
+ locals_keys = @@template_args[render_symbol].keys | locals
+ @@template_args[render_symbol] = Haml::Util.to_hash(locals_keys.map {|k| [k, true]})
+
+ options = Haml::Template.options.dup
+ options[:filename] = file_name || 'compiled-template'
+
+ begin
+ Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals_keys)
+ rescue Exception => e
+ if logger
+ logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+ logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+ end
+
+ base_path = if defined?(extract_base_path_from)
+ # Rails 2.0.x
+ extract_base_path_from(file_name) || view_paths.first
+ else
+ # Rails <=1.2.6
+ @base_path
+ end
+ raise ActionView::TemplateError.new(base_path, file_name || template, @assigns, template, e)
+ end
+
+ @@compile_time[render_symbol] = Time.now
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/plugin.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/plugin.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/plugin.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/template/plugin.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,71 @@
+# This file makes Haml work with Rails
+# using the > 2.0.1 template handler API.
+
+module Haml
+ class Plugin < ActionView::TemplateHandler
+ include ActionView::TemplateHandlers::Compilable if defined?(ActionView::TemplateHandlers::Compilable)
+
+ def compile(template)
+ options = Haml::Template.options.dup
+
+ # template is a template object in Rails >=2.1.0,
+ # a source string previously
+ if template.respond_to? :source
+ # Template has a generic identifier in Rails >=3.0.0
+ options[:filename] = template.respond_to?(:identifier) ? template.identifier : template.filename
+ source = template.source
+ else
+ source = template
+ end
+
+ Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
+ end
+
+ def cache_fragment(block, name = {}, options = nil)
+ @view.fragment_for(block, name, options) do
+ eval("_hamlout.buffer", block.binding)
+ end
+ end
+ end
+end
+
+if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
+ ActionView::Template
+else
+ ActionView::Base
+end.register_template_handler(:haml, Haml::Plugin)
+
+# In Rails 2.0.2, ActionView::TemplateError took arguments
+# that we can't fill in from the Haml::Plugin context.
+# Thus, we've got to monkeypatch ActionView::Base to catch the error.
+if ActionView::TemplateError.instance_method(:initialize).arity == 5
+ class ActionView::Base
+ def compile_template(handler, template, file_name, local_assigns)
+ render_symbol = assign_method_name(handler, template, file_name)
+
+ # Move begin up two lines so it captures compilation exceptions.
+ begin
+ render_source = create_template_source(handler, template, render_symbol, local_assigns.keys)
+ line_offset = @@template_args[render_symbol].size + handler.line_offset
+
+ file_name = 'compiled-template' if file_name.blank?
+ CompiledTemplates.module_eval(render_source, file_name, -line_offset)
+ rescue Exception => e # errors from template code
+ if logger
+ logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+ logger.debug "Function body: #{render_source}"
+ logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+ end
+
+ # There's no way to tell Haml about the filename,
+ # so we've got to insert it ourselves.
+ e.backtrace[0].gsub!('(haml)', file_name) if e.is_a?(Haml::Error)
+
+ raise ActionView::TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e)
+ end
+
+ @@compile_time[render_symbol] = Time.now
+ # logger.debug "Compiled template #{file_name || template}\n ==> #{render_symbol}" if logger
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/util.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/util.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/util.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/util.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,228 @@
+require 'erb'
+require 'set'
+require 'enumerator'
+
+module Haml
+ # A module containing various useful functions.
+ module Util
+ extend self
+
+ # An array of ints representing the Ruby version number.
+ RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
+
+ # Returns the path of a file relative to the Haml root directory.
+ #
+ # @param file [String] The filename relative to the Haml root
+ # @return [String] The filename relative to the the working directory
+ def scope(file)
+ File.join(File.dirname(__FILE__), '..', '..', file)
+ end
+
+ # Converts an array of `[key, value]` pairs to a hash.
+ # For example:
+ #
+ # to_hash([[:foo, "bar"], [:baz, "bang"]])
+ # #=> {:foo => "bar", :baz => "bang"}
+ #
+ # @param arr [Array<(Object, Object)>] An array of pairs
+ # @return [Hash] A hash
+ def to_hash(arr)
+ arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
+ end
+
+ # Maps the keys in a hash according to a block.
+ # For example:
+ #
+ # map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
+ # #=> {"foo" => "bar", "baz" => "bang"}
+ #
+ # @param hash [Hash] The hash to map
+ # @yield [key] A block in which the keys are transformed
+ # @yieldparam key [Object] The key that should be mapped
+ # @yieldreturn [Object] The new value for the key
+ # @return [Hash] The mapped hash
+ # @see #map_vals
+ # @see #map_hash
+ def map_keys(hash)
+ to_hash(hash.map {|k, v| [yield(k), v]})
+ end
+
+ # Maps the values in a hash according to a block.
+ # For example:
+ #
+ # map_values({:foo => "bar", :baz => "bang"}) {|v| v.to_sym}
+ # #=> {:foo => :bar, :baz => :bang}
+ #
+ # @param hash [Hash] The hash to map
+ # @yield [value] A block in which the values are transformed
+ # @yieldparam value [Object] The value that should be mapped
+ # @yieldreturn [Object] The new value for the value
+ # @return [Hash] The mapped hash
+ # @see #map_keys
+ # @see #map_hash
+ def map_vals(hash)
+ to_hash(hash.map {|k, v| [k, yield(v)]})
+ end
+
+ # Maps the key-value pairs of a hash according to a block.
+ # For example:
+ #
+ # map_hash({:foo => "bar", :baz => "bang"}) {|k, v| [k.to_s, v.to_sym]}
+ # #=> {"foo" => :bar, "baz" => :bang}
+ #
+ # @param hash [Hash] The hash to map
+ # @yield [key, value] A block in which the key-value pairs are transformed
+ # @yieldparam [key] The hash key
+ # @yieldparam [value] The hash value
+ # @yieldreturn [(Object, Object)] The new value for the `[key, value]` pair
+ # @return [Hash] The mapped hash
+ # @see #map_keys
+ # @see #map_vals
+ def map_hash(hash, &block)
+ to_hash(hash.map(&block))
+ end
+
+ # Computes the powerset of the given array.
+ # This is the set of all subsets of the array.
+ # For example:
+ #
+ # powerset([1, 2, 3]) #=>
+ # Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]
+ #
+ # @param arr [Enumerable]
+ # @return [Set<Set>] The subsets of `arr`
+ def powerset(arr)
+ arr.inject([Set.new].to_set) do |powerset, el|
+ new_powerset = Set.new
+ powerset.each do |subset|
+ new_powerset << subset
+ new_powerset << subset + [el]
+ end
+ new_powerset
+ end
+ end
+
+ # Concatenates all strings that are adjacent in an array,
+ # while leaving other elements as they are.
+ # For example:
+ #
+ # merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
+ # #=> [1, "foobar", 2, "baz"]
+ #
+ # @param enum [Enumerable]
+ # @return [Array] The enumerable with strings merged
+ def merge_adjacent_strings(enum)
+ e = enum.inject([]) do |a, e|
+ if e.is_a?(String) && a.last.is_a?(String)
+ a.last << e
+ else
+ a << e
+ end
+ a
+ end
+ end
+
+ # Whether or not this is running under Ruby 1.8 or lower.
+ #
+ # @return [Boolean]
+ def ruby1_8?
+ Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
+ end
+
+ # Checks to see if a class has a given method.
+ # For example:
+ #
+ # Haml::Util.has?(:public_instance_method, String, :gsub) #=> true
+ #
+ # Method collections like `Class#instance_methods`
+ # return strings in Ruby 1.8 and symbols in Ruby 1.9 and on,
+ # so this handles checking for them in a compatible way.
+ #
+ # @param attr [#to_s] The (singular) name of the method-collection method
+ # (e.g. `:instance_methods`, `:private_methods`)
+ # @param klass [Module] The class to check the methods of which to check
+ # @param method [String, Symbol] The name of the method do check for
+ # @return [Boolean] Whether or not the given collection has the given method
+ def has?(attr, klass, method)
+ klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
+ end
+
+ # A version of `Enumerable#enum_with_index` that works in Ruby 1.8 and 1.9.
+ #
+ # @param enum [Enumerable] The enumerable to get the enumerator for
+ # @return [Enumerator] The with-index enumerator
+ def enum_with_index(enum)
+ ruby1_8? ? enum.enum_with_index : enum.each_with_index
+ end
+
+ # The context in which the ERB for \{#def\_static\_method} will be run.
+ class StaticConditionalContext
+ # @param set [#include?] The set of variables that are defined for this context.
+ def initialize(set)
+ @set = set
+ end
+
+ # Checks whether or not a variable is defined for this context.
+ #
+ # @param name [Symbol] The name of the variable
+ # @return [Boolean]
+ def method_missing(name, *args, &block)
+ super unless args.empty? && block.nil?
+ @set.include?(name)
+ end
+ end
+
+ # This is used for methods in {Haml::Buffer} that need to be very fast,
+ # and take a lot of boolean parameters
+ # that are known at compile-time.
+ # Instead of passing the parameters in normally,
+ # a separate method is defined for every possible combination of those parameters;
+ # these are then called using \{#static\_method\_name}.
+ #
+ # To define a static method, an ERB template for the method is provided.
+ # All conditionals based on the static parameters
+ # are done as embedded Ruby within this template.
+ # For example:
+ #
+ # def_static_method(Foo, :my_static_method, [:foo, :bar], :baz, :bang, <<RUBY)
+ # <% if baz && bang %>
+ # return foo + bar
+ # <% elsif baz || bang %>
+ # return foo - bar
+ # <% else %>
+ # return 17
+ # <% end %>
+ # RUBY
+ #
+ # \{#static\_method\_name} can be used to call static methods.
+ #
+ # @overload def_static_method(klass, name, args, *vars, erb)
+ # @param klass [Module] The class on which to define the static method
+ # @param name [#to_s] The (base) name of the static method
+ # @param args [Array<Symbol>] The names of the arguments to the defined methods
+ # (**not** to the ERB template)
+ # @param vars [Array<Symbol>] The names of the static boolean variables
+ # to be made available to the ERB template
+ # @param erb [String] The template for the method code
+ def def_static_method(klass, name, args, *vars)
+ erb = vars.pop
+ powerset(vars).each do |set|
+ context = StaticConditionalContext.new(set).instance_eval {binding}
+ klass.class_eval(<<METHOD)
+def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
+ #{ERB.new(erb).result(context)}
+end
+METHOD
+ end
+ end
+
+ # Computes the name for a method defined via \{#def\_static\_method}.
+ #
+ # @param name [String] The base name of the static method
+ # @param vars [Array<Boolean>] The static variable assignment
+ # @return [String] The real name of the static method
+ def static_method_name(name, *vars)
+ "#{name}_#{vars.map {|v| !!v}.join('_')}"
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/version.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/version.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/version.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/haml/version.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,64 @@
+require 'haml/util'
+
+module Haml
+ # Handles Haml version-reporting.
+ # Haml not only reports the standard three version numbers,
+ # but its Git revision hash as well,
+ # if it was installed from Git.
+ module Version
+ include Haml::Util
+
+ # Returns a hash representing the version of Haml.
+ # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
+ # The `:name` key has the name of the version.
+ # The `:string` key contains a human-readable string representation of the version.
+ # The `:number` key is the major, minor, and teeny keys separated by periods.
+ # If Haml is checked out from Git, the `:rev` key will have the revision hash.
+ # For example:
+ #
+ # {
+ # :string => "2.1.0.9616393",
+ # :rev => "9616393b8924ef36639c7e82aa88a51a24d16949",
+ # :number => "2.1.0",
+ # :major => 2, :minor => 1, :teeny => 0
+ # }
+ #
+ # @return [Hash<Symbol, String/Fixnum>] The version hash
+ def version
+ return @@version if defined?(@@version)
+
+ numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
+ name = File.read(scope('VERSION_NAME')).strip
+ @@version = {
+ :major => numbers[0],
+ :minor => numbers[1],
+ :teeny => numbers[2],
+ :name => name
+ }
+ @@version[:number] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
+ @@version[:string] = @@version[:number].dup
+
+ if File.exists?(scope('REVISION'))
+ rev = File.read(scope('REVISION')).strip
+ rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
+ end
+
+ if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
+ rev = File.read(scope('.git/HEAD')).strip
+ if rev =~ /^ref: (.*)$/
+ rev = File.read(scope(".git/#{$1}")).strip
+ end
+ end
+
+ if rev
+ @@version[:rev] = rev
+ unless rev[0] == ?(
+ @@version[:string] << "." << rev[0...7]
+ end
+ @@version[:string] << " (#{name})"
+ end
+
+ @@version
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,24 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'haml/version'
+
+# The module that contains everything Sass-related:
+#
+# * {Sass::Engine} is the class used to render Sass within Ruby code.
+# * {Sass::Plugin} is interfaces with web frameworks (Rails and Merb in particular).
+# * {Sass::SyntaxError} is raised when Sass encounters an error.
+# * {Sass::CSS} handles conversion of CSS to Sass.
+#
+# Also see the {file:SASS_REFERENCE.md full Sass reference}.
+module Sass
+ extend Haml::Version
+
+ # A string representing the version of Sass.
+ # A more fine-grained representation is available from {Sass.version}.
+ VERSION = version[:string] unless defined?(Sass::VERSION)
+end
+
+require 'haml/util'
+require 'sass/engine'
+require 'sass/plugin' if defined?(Merb::Plugins)
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/css.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/css.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/css.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/css.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,402 @@
+require File.dirname(__FILE__) + '/../sass'
+require 'sass/tree/node'
+require 'strscan'
+
+module Sass
+ module Tree
+ class Node
+ # Converts a node to Sass code that will generate it.
+ #
+ # @param tabs [Fixnum] The amount of tabulation to use for the Sass code
+ # @param opts [Hash<Symbol, Object>] An options hash (see {Sass::CSS#initialize})
+ # @return [String] The Sass code corresponding to the node
+ def to_sass(tabs = 0, opts = {})
+ result = ''
+
+ children.each do |child|
+ result << "#{' ' * tabs}#{child.to_sass(0, opts)}\n"
+ end
+
+ result
+ end
+ end
+
+ class RuleNode
+ # @see Node#to_sass
+ def to_sass(tabs, opts = {})
+ str = "\n#{' ' * tabs}#{rules.first}#{children.any? { |c| c.is_a? PropNode } ? "\n" : ''}"
+
+ children.each do |child|
+ str << "#{child.to_sass(tabs + 1, opts)}"
+ end
+
+ str
+ end
+ end
+
+ class PropNode
+ # @see Node#to_sass
+ def to_sass(tabs, opts = {})
+ "#{' ' * tabs}#{opts[:old] ? ':' : ''}#{name}#{opts[:old] ? '' : ':'} #{value}\n"
+ end
+ end
+
+ class DirectiveNode
+ # @see Node#to_sass
+ def to_sass(tabs, opts = {})
+ "#{' ' * tabs}#{value}#{children.map {|c| c.to_sass(tabs + 1, opts)}}\n"
+ end
+ end
+ end
+
+ # This class converts CSS documents into Sass templates.
+ # It works by parsing the CSS document into a {Sass::Tree} structure,
+ # and then applying various transformations to the structure
+ # to produce more concise and idiomatic Sass.
+ #
+ # Example usage:
+ #
+ # Sass::CSS.new("p { color: blue }").render #=> "p\n color: blue"
+ class CSS
+ # @param template [String] The CSS code
+ # @option options :old [Boolean] (false)
+ # Whether or not to output old property syntax
+ # (`:color blue` as opposed to `color: blue`).
+ def initialize(template, options = {})
+ if template.is_a? IO
+ template = template.read
+ end
+
+ @options = options.dup
+ # Backwards compatibility
+ @options[:old] = true if @options[:alternate] == false
+ @template = StringScanner.new(template)
+ end
+
+ # Converts the CSS template into Sass code.
+ #
+ # @return [String] The resulting Sass code
+ def render
+ begin
+ build_tree.to_sass(0, @options).strip + "\n"
+ rescue Exception => err
+ line = @template.string[0...@template.pos].split("\n").size
+
+ err.backtrace.unshift "(css):#{line}"
+ raise err
+ end
+ end
+
+ private
+
+ # Parses the CSS template and applies various transformations
+ #
+ # @return [Tree::Node] The root node of the parsed tree
+ def build_tree
+ root = Tree::Node.new
+ whitespace
+ rules root
+ expand_commas root
+ parent_ref_rules root
+ remove_parent_refs root
+ flatten_rules root
+ fold_commas root
+ root
+ end
+
+ # Parses a set of CSS rules.
+ #
+ # @param root [Tree::Node] The parent node of the rules
+ def rules(root)
+ while r = rule
+ root << r
+ whitespace
+ end
+ end
+
+ # Parses a single CSS rule.
+ #
+ # @return [Tree::Node] The parsed rule
+ def rule
+ rule = ""
+ loop do
+ token = @template.scan(/(?:[^\{\};\/\s]|\/[^*])+/)
+ if token.nil?
+ return if rule.empty?
+ break
+ end
+ rule << token
+ break unless @template.match?(/\s|\/\*/)
+ whitespace
+ rule << " "
+ end
+
+ rule.strip!
+ directive = rule[0] == ?@
+
+ if directive
+ node = Tree::DirectiveNode.new(rule)
+ return node if @template.scan(/;/)
+
+ assert_match /\{/
+ whitespace
+
+ rules(node)
+ return node
+ end
+
+ assert_match /\{/
+ node = Tree::RuleNode.new(rule)
+ properties(node)
+ return node
+ end
+
+ # Parses a set of CSS properties within a rule.
+ #
+ # @param rule [Tree::RuleNode] The parent node of the properties
+ def properties(rule)
+ while @template.scan(/[^:\}\s]+/)
+ name = @template[0]
+ whitespace
+
+ assert_match /:/
+
+ value = ''
+ while @template.scan(/[^;\s\}]+/)
+ value << @template[0] << whitespace
+ end
+
+ assert_match /(;|(?=\}))/
+ rule << Tree::PropNode.new(name, value, nil)
+ end
+
+ assert_match /\}/
+ end
+
+ # Moves the scanner over a section of whitespace or comments.
+ #
+ # @return [String] The ignored whitespace
+ def whitespace
+ space = @template.scan(/\s*/) || ''
+
+ # If we've hit a comment,
+ # go past it and look for more whitespace
+ if @template.scan(/\/\*/)
+ @template.scan_until(/\*\//)
+ return space + whitespace
+ end
+ return space
+ end
+
+ # Moves the scanner over a regular expression,
+ # raising an exception if it doesn't match.
+ #
+ # @param re [Regexp] The regular expression to assert
+ def assert_match(re)
+ if @template.scan(re)
+ whitespace
+ return
+ end
+
+ line = @template.string[0..@template.pos].count "\n"
+ pos = @template.pos
+
+ after = @template.string[pos - 15...pos]
+ after = "..." + after if pos >= 15
+
+ # Display basic regexps as plain old strings
+ expected = re.source == Regexp.escape(re.source) ? "\"#{re.source}\"" : re.inspect
+
+ was = @template.rest[0...15]
+ was += "..." if @template.rest.size >= 15
+ raise Exception.new(<<MESSAGE)
+Invalid CSS on line #{line + 1} after #{after.inspect}:
+ expected #{expected}, was #{was.inspect}
+MESSAGE
+ end
+
+ # Transform
+ #
+ # foo, bar, baz
+ # color: blue
+ #
+ # into
+ #
+ # foo
+ # color: blue
+ # bar
+ # color: blue
+ # baz
+ # color: blue
+ #
+ # @param root [Tree::Node] The parent node
+ def expand_commas(root)
+ root.children.map! do |child|
+ next child unless Tree::RuleNode === child && child.rules.first.include?(',')
+ child.rules.first.split(',').map do |rule|
+ node = Tree::RuleNode.new(rule.strip)
+ node.children = child.children
+ node
+ end
+ end
+ root.children.flatten!
+ end
+
+ # Make rules use parent refs so that
+ #
+ # foo
+ # color: green
+ # foo.bar
+ # color: blue
+ #
+ # becomes
+ #
+ # foo
+ # color: green
+ # &.bar
+ # color: blue
+ #
+ # This has the side effect of nesting rules,
+ # so that
+ #
+ # foo
+ # color: green
+ # foo bar
+ # color: red
+ # foo baz
+ # color: blue
+ #
+ # becomes
+ #
+ # foo
+ # color: green
+ # & bar
+ # color: red
+ # & baz
+ # color: blue
+ #
+ # @param root [Tree::Node] The parent node
+ def parent_ref_rules(root)
+ current_rule = nil
+ root.children.select { |c| Tree::RuleNode === c }.each do |child|
+ root.children.delete child
+ first, rest = child.rules.first.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first
+
+ if current_rule.nil? || current_rule.rules.first != first
+ current_rule = Tree::RuleNode.new(first)
+ root << current_rule
+ end
+
+ if rest
+ child.rules = ["&" + rest]
+ current_rule << child
+ else
+ current_rule.children += child.children
+ end
+ end
+
+ root.children.each { |v| parent_ref_rules(v) }
+ end
+
+ # Remove useless parent refs so that
+ #
+ # foo
+ # & bar
+ # color: blue
+ #
+ # becomes
+ #
+ # foo
+ # bar
+ # color: blue
+ #
+ # @param root [Tree::Node] The parent node
+ def remove_parent_refs(root)
+ root.children.each do |child|
+ if child.is_a?(Tree::RuleNode)
+ child.rules.first.gsub! /^& +/, ''
+ remove_parent_refs child
+ end
+ end
+ end
+
+ # Flatten rules so that
+ #
+ # foo
+ # bar
+ # color: red
+ #
+ # becomes
+ #
+ # foo bar
+ # color: red
+ #
+ # and
+ #
+ # foo
+ # &.bar
+ # color: blue
+ #
+ # becomes
+ #
+ # foo.bar
+ # color: blue
+ #
+ # @param root [Tree::Node] The parent node
+ def flatten_rules(root)
+ root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) }
+ end
+
+ # Flattens a single rule
+ #
+ # @param rule [Tree::RuleNode] The candidate for flattening
+ # @see #flatten_rules
+ def flatten_rule(rule)
+ while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
+ child = rule.children.first
+
+ if child.rules.first[0] == ?&
+ rule.rules = [child.rules.first.gsub(/^&/, rule.rules.first)]
+ else
+ rule.rules = ["#{rule.rules.first} #{child.rules.first}"]
+ end
+
+ rule.children = child.children
+ end
+
+ flatten_rules(rule)
+ end
+
+ # Transform
+ #
+ # foo
+ # bar
+ # color: blue
+ # baz
+ # color: blue
+ #
+ # into
+ #
+ # foo
+ # bar, baz
+ # color: blue
+ #
+ # @param rule [Tree::RuleNode] The candidate for flattening
+ def fold_commas(root)
+ prev_rule = nil
+ root.children.map! do |child|
+ next child unless child.is_a?(Tree::RuleNode)
+
+ if prev_rule && prev_rule.children == child.children
+ prev_rule.rules.first << ", #{child.rules.first}"
+ next nil
+ end
+
+ fold_commas(child)
+ prev_rule = child
+ child
+ end
+ root.children.compact!
+ end
+ end
+end
Added: incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/engine.rb
URL: http://svn.apache.org/viewvc/incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/engine.rb?rev=961978&view=auto
==============================================================================
--- incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/engine.rb (added)
+++ incubator/deltacloud/trunk/framework/vendor/plugins/haml/lib/sass/engine.rb Thu Jul 8 23:14:13 2010
@@ -0,0 +1,471 @@
+require 'strscan'
+require 'digest/sha1'
+require 'sass/tree/node'
+require 'sass/tree/rule_node'
+require 'sass/tree/comment_node'
+require 'sass/tree/prop_node'
+require 'sass/tree/directive_node'
+require 'sass/tree/variable_node'
+require 'sass/tree/mixin_def_node'
+require 'sass/tree/mixin_node'
+require 'sass/tree/if_node'
+require 'sass/tree/while_node'
+require 'sass/tree/for_node'
+require 'sass/tree/debug_node'
+require 'sass/tree/import_node'
+require 'sass/environment'
+require 'sass/script'
+require 'sass/error'
+require 'sass/files'
+require 'haml/shared'
+
+module Sass
+ # A Sass mixin.
+ #
+ # `name`: `String`
+ # : The name of the mixin.
+ #
+ # `args`: `Array<(String, Script::Node)>`
+ # : The arguments for the mixin.
+ # Each element is a tuple containing the name of the argument
+ # and the parse tree for the default value of the argument.
+ #
+ # `environment`: {Sass::Environment}
+ # : The environment in which the mixin was defined.
+ # This is captured so that the mixin can have access
+ # to local variables defined in its scope.
+ #
+ # `tree`: {Sass::Tree::Node}
+ # : The parse tree for the mixin.
+ Mixin = Struct.new(:name, :args, :environment, :tree)
+
+ # This class handles the parsing and compilation of the Sass template.
+ # Example usage:
+ #
+ # template = File.load('stylesheets/sassy.sass')
+ # sass_engine = Sass::Engine.new(template)
+ # output = sass_engine.render
+ # puts output
+ class Engine
+ include Haml::Util
+
+ # A line of Sass code.
+ #
+ # `text`: `String`
+ # : The text in the line, without any whitespace at the beginning or end.
+ #
+ # `tabs`: `Fixnum`
+ # : The level of indentation of the line.
+ #
+ # `index`: `Fixnum`
+ # : The line number in the original document.
+ #
+ # `offset`: `Fixnum`
+ # : The number of bytes in on the line that the text begins.
+ # This ends up being the number of bytes of leading whitespace.
+ #
+ # `filename`: `String`
+ # : The name of the file in which this line appeared.
+ #
+ # `children`: `Array<Line>`
+ # : The lines nested below this one.
+ class Line < Struct.new(:text, :tabs, :index, :offset, :filename, :children)
+ def comment?
+ text[0] == COMMENT_CHAR && (text[1] == SASS_COMMENT_CHAR || text[1] == CSS_COMMENT_CHAR)
+ end
+ end
+
+ # The character that begins a CSS property.
+ PROPERTY_CHAR = ?:
+
+ # The character that designates that
+ # a property should be assigned to a SassScript expression.
+ SCRIPT_CHAR = ?=
+
+ # The character that designates the beginning of a comment,
+ # either Sass or CSS.
+ COMMENT_CHAR = ?/
+
+ # The character that follows the general COMMENT_CHAR and designates a Sass comment,
+ # which is not output as a CSS comment.
+ SASS_COMMENT_CHAR = ?/
+
+ # The character that follows the general COMMENT_CHAR and designates a CSS comment,
+ # which is embedded in the CSS document.
+ CSS_COMMENT_CHAR = ?*
+
+ # The character used to denote a compiler directive.
+ DIRECTIVE_CHAR = ?@
+
+ # Designates a non-parsed rule.
+ ESCAPE_CHAR = ?\\
+
+ # Designates block as mixin definition rather than CSS rules to output
+ MIXIN_DEFINITION_CHAR = ?=
+
+ # Includes named mixin declared using MIXIN_DEFINITION_CHAR
+ MIXIN_INCLUDE_CHAR = ?+
+
+ # The regex that matches properties of the form <tt>name: prop</tt>.
+ PROPERTY_NEW_MATCHER = /^[^\s:"]+\s*[=:](\s|$)/
+
+ # The regex that matches and extracts data from
+ # properties of the form <tt>name: prop</tt>.
+ PROPERTY_NEW = /^([^\s=:"]+)(\s*=|:)(?:\s+|$)(.*)/
+
+ # The regex that matches and extracts data from
+ # properties of the form <tt>:name prop</tt>.
+ PROPERTY_OLD = /^:([^\s=:"]+)\s*(=?)(?:\s+|$)(.*)/
+
+ # The default options for Sass::Engine.
+ DEFAULT_OPTIONS = {
+ :style => :nested,
+ :load_paths => ['.'],
+ :cache => true,
+ :cache_location => './.sass-cache',
+ }.freeze
+
+ # @param template [String] The Sass template.
+ # @param options [Hash<Symbol, Object>] An options hash;
+ # see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+ def initialize(template, options={})
+ @options = DEFAULT_OPTIONS.merge(options)
+ @template = template
+
+ # Backwards compatibility
+ @options[:property_syntax] ||= @options[:attribute_syntax]
+ case @options[:property_syntax]
+ when :alternate; @options[:property_syntax] = :new
+ when :normal; @options[:property_syntax] = :old
+ end
+ end
+
+ # Render the template to CSS.
+ #
+ # @return [String] The CSS
+ # @raise [Sass::SyntaxError] if there's an error in the document
+ def render
+ to_tree.render
+ end
+
+ alias_method :to_css, :render
+
+ # Parses the document into its parse tree.
+ #
+ # @return [Sass::Tree::Node] The root of the parse tree.
+ # @raise [Sass::SyntaxError] if there's an error in the document
+ def to_tree
+ root = Tree::Node.new
+ append_children(root, tree(tabulate(@template)).first, true)
+ root.options = @options
+ root
+ rescue SyntaxError => e; e.add_metadata(@options[:filename], @line)
+ end
+
+ private
+
+ def tabulate(string)
+ tab_str = nil
+ first = true
+ lines = []
+ string.gsub(/\r|\n|\r\n|\r\n/, "\n").scan(/^.*?$/).each_with_index do |line, index|
+ index += (@options[:line] || 1)
+ if line.strip.empty?
+ lines.last.text << "\n" if lines.last && lines.last.comment?
+ next
+ end
+
+ line_tab_str = line[/^\s*/]
+ unless line_tab_str.empty?
+ tab_str ||= line_tab_str
+
+ raise SyntaxError.new("Indenting at the beginning of the document is illegal.", index) if first
+ if tab_str.include?(?\s) && tab_str.include?(?\t)
+ raise SyntaxError.new("Indentation can't use both tabs and spaces.", index)
+ end
+ end
+ first &&= !tab_str.nil?
+ if tab_str.nil?
+ lines << Line.new(line.strip, 0, index, 0, @options[:filename], [])
+ next
+ end
+
+ if lines.last && lines.last.comment? && line =~ /^(?:#{tab_str}){#{lines.last.tabs + 1}}(.*)$/
+ lines.last.text << "\n" << $1
+ next
+ end
+
+ line_tabs = line_tab_str.scan(tab_str).size
+ raise SyntaxError.new(<<END.strip.gsub("\n", ' '), index) if tab_str * line_tabs != line_tab_str
+Inconsistent indentation: #{Haml::Shared.human_indentation line_tab_str, true} used for indentation,
+but the rest of the document was indented using #{Haml::Shared.human_indentation tab_str}.
+END
+ lines << Line.new(line.strip, line_tabs, index, tab_str.size, @options[:filename], [])
+ end
+ lines
+ end
+
+ def tree(arr, i = 0)
+ return [], i if arr[i].nil?
+
+ base = arr[i].tabs
+ nodes = []
+ while (line = arr[i]) && line.tabs >= base
+ if line.tabs > base
+ if line.tabs > base + 1
+ raise SyntaxError.new("The line was indented #{line.tabs - base} levels deeper than the previous line.", line.index)
+ end
+
+ nodes.last.children, i = tree(arr, i)
+ else
+ nodes << line
+ i += 1
+ end
+ end
+ return nodes, i
+ end
+
+ def build_tree(parent, line, root = false)
+ @line = line.index
+ node_or_nodes = parse_line(parent, line, root)
+
+ Array(node_or_nodes).each do |node|
+ # Node is a symbol if it's non-outputting, like a variable assignment
+ next unless node.is_a? Tree::Node
+
+ node.line = line.index
+ node.filename = line.filename
+
+ if node.is_a?(Tree::CommentNode)
+ node.lines = line.children
+ else
+ append_children(node, line.children, false)
+ end
+ end
+
+ node_or_nodes
+ end
+
+ def append_children(parent, children, root)
+ continued_rule = nil
+ children.each do |line|
+ child = build_tree(parent, line, root)
+
+ if child.is_a?(Tree::RuleNode) && child.continued?
+ raise SyntaxError.new("Rules can't end in commas.", child.line) unless child.children.empty?
+ if continued_rule
+ continued_rule.add_rules child
+ else
+ continued_rule = child
+ end
+ next
+ end
+
+ if continued_rule
+ raise SyntaxError.new("Rules can't end in commas.", continued_rule.line) unless child.is_a?(Tree::RuleNode)
+ continued_rule.add_rules child
+ continued_rule.children = child.children
+ continued_rule, child = nil, continued_rule
+ end
+
+ check_for_no_children(child)
+ validate_and_append_child(parent, child, line, root)
+ end
+
+ raise SyntaxError.new("Rules can't end in commas.", continued_rule.line) if continued_rule
+
+ parent
+ end
+
+ def validate_and_append_child(parent, child, line, root)
+ unless root
+ case child
+ when Tree::MixinDefNode
+ raise SyntaxError.new("Mixins may only be defined at the root of a document.", line.index)
+ when Tree::ImportNode
+ raise SyntaxError.new("Import directives may only be used at the root of a document.", line.index)
+ end
+ end
+
+ case child
+ when Array
+ child.each {|c| validate_and_append_child(parent, c, line, root)}
+ when Tree::Node
+ parent << child
+ end
+ end
+
+ def check_for_no_children(node)
+ return unless node.is_a?(Tree::RuleNode) && node.children.empty?
+ warning = (node.rules.size == 1) ? <<SHORT : <<LONG
+WARNING:
+Selector #{node.rules.first.inspect} doesn't have any properties and will not be rendered.
+SHORT
+
+WARNING:
+Selector
+ #{node.rules.join("\n ")}
+doesn't have any properties and will not be rendered.
+LONG
+
+ warn(warning.strip)
+ end
+
+ def parse_line(parent, line, root)
+ case line.text[0]
+ when PROPERTY_CHAR
+ if line.text[1] != PROPERTY_CHAR
+ parse_property(line, PROPERTY_OLD)
+ else
+ # Support CSS3-style pseudo-elements,
+ # which begin with ::
+ Tree::RuleNode.new(line.text)
+ end
+ when Script::VARIABLE_CHAR
+ parse_variable(line)
+ when COMMENT_CHAR
+ parse_comment(line.text)
+ when DIRECTIVE_CHAR
+ parse_directive(parent, line, root)
+ when ESCAPE_CHAR
+ Tree::RuleNode.new(line.text[1..-1])
+ when MIXIN_DEFINITION_CHAR
+ parse_mixin_definition(line)
+ when MIXIN_INCLUDE_CHAR
+ if line.text[1].nil? || line.text[1] == ?\s
+ Tree::RuleNode.new(line.text)
+ else
+ parse_mixin_include(line, root)
+ end
+ else
+ if line.text =~ PROPERTY_NEW_MATCHER
+ parse_property(line, PROPERTY_NEW)
+ else
+ Tree::RuleNode.new(line.text)
+ end
+ end
+ end
+
+ def parse_property(line, property_regx)
+ name, eq, value = line.text.scan(property_regx)[0]
+
+ if name.nil? || value.nil?
+ raise SyntaxError.new("Invalid property: \"#{line.text}\".", @line)
+ end
+ expr = if (eq.strip[0] == SCRIPT_CHAR)
+ parse_script(value, :offset => line.offset + line.text.index(value))
+ else
+ value
+ end
+ Tree::PropNode.new(name, expr, property_regx == PROPERTY_OLD ? :old : :new)
+ end
+
+ def parse_variable(line)
+ name, op, value = line.text.scan(Script::MATCH)[0]
+ raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath variable declarations.", @line + 1) unless line.children.empty?
+ raise SyntaxError.new("Invalid variable: \"#{line.text}\".", @line) unless name && value
+
+ Tree::VariableNode.new(name, parse_script(value, :offset => line.offset + line.text.index(value)), op == '||=')
+ end
+
+ def parse_comment(line)
+ if line[1] == CSS_COMMENT_CHAR || line[1] == SASS_COMMENT_CHAR
+ Tree::CommentNode.new(line, line[1] == SASS_COMMENT_CHAR)
+ else
+ Tree::RuleNode.new(line)
+ end
+ end
+
+ def parse_directive(parent, line, root)
+ directive, whitespace, value = line.text[1..-1].split(/(\s+)/, 2)
+ offset = directive.size + whitespace.size + 1 if whitespace
+
+ # If value begins with url( or ",
+ # it's a CSS @import rule and we don't want to touch it.
+ if directive == "import" && value !~ /^(url\(|")/
+ raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.", @line + 1) unless line.children.empty?
+ value.split(/,\s*/).map {|f| Tree::ImportNode.new(f)}
+ elsif directive == "for"
+ parse_for(line, root, value)
+ elsif directive == "else"
+ parse_else(parent, line, value)
+ elsif directive == "while"
+ raise SyntaxError.new("Invalid while directive '@while': expected expression.") unless value
+ Tree::WhileNode.new(parse_script(value, :offset => offset))
+ elsif directive == "if"
+ raise SyntaxError.new("Invalid if directive '@if': expected expression.") unless value
+ Tree::IfNode.new(parse_script(value, :offset => offset))
+ elsif directive == "debug"
+ raise SyntaxError.new("Invalid debug directive '@debug': expected expression.") unless value
+ raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath debug directives.", @line + 1) unless line.children.empty?
+ offset = line.offset + line.text.index(value).to_i
+ Tree::DebugNode.new(parse_script(value, :offset => offset))
+ else
+ Tree::DirectiveNode.new(line.text)
+ end
+ end
+
+ def parse_for(line, root, text)
+ var, from_expr, to_name, to_expr = text.scan(/^([^\s]+)\s+from\s+(.+)\s+(to|through)\s+(.+)$/).first
+
+ if var.nil? # scan failed, try to figure out why for error message
+ if text !~ /^[^\s]+/
+ expected = "variable name"
+ elsif text !~ /^[^\s]+\s+from\s+.+/
+ expected = "'from <expr>'"
+ else
+ expected = "'to <expr>' or 'through <expr>'"
+ end
+ raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.", @line)
+ end
+ raise SyntaxError.new("Invalid variable \"#{var}\".", @line) unless var =~ Script::VALIDATE
+
+ parsed_from = parse_script(from_expr, :offset => line.offset + line.text.index(from_expr))
+ parsed_to = parse_script(to_expr, :offset => line.offset + line.text.index(to_expr))
+ Tree::ForNode.new(var[1..-1], parsed_from, parsed_to, to_name == 'to')
+ end
+
+ def parse_else(parent, line, text)
+ previous = parent.last
+ raise SyntaxError.new("@else must come after @if.") unless previous.is_a?(Tree::IfNode)
+
+ if text
+ if text !~ /^if\s+(.+)/
+ raise SyntaxError.new("Invalid else directive '@else #{text}': expected 'if <expr>'.", @line)
+ end
+ expr = parse_script($1, :offset => line.offset + line.text.index($1))
+ end
+
+ node = Tree::IfNode.new(expr)
+ append_children(node, line.children, false)
+ previous.add_else node
+ nil
+ end
+
+ def parse_mixin_definition(line)
+ name, arg_string = line.text.scan(/^=\s*([^(]+)(.*)$/).first
+ raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".", @line) if name.nil?
+
+ offset = line.offset + line.text.size - arg_string.size
+ args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_definition_arglist
+ default_arg_found = false
+ Tree::MixinDefNode.new(name, args)
+ end
+
+ def parse_mixin_include(line, root)
+ name, arg_string = line.text.scan(/^\+\s*([^(]+)(.*)$/).first
+ raise SyntaxError.new("Invalid mixin include \"#{line.text}\".", @line) if name.nil?
+
+ offset = line.offset + line.text.size - arg_string.size
+ args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_include_arglist
+ raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.", @line + 1) unless line.children.empty?
+ Tree::MixinNode.new(name, args)
+ end
+
+ def parse_script(script, options = {})
+ line = options[:line] || @line
+ offset = options[:offset] || 0
+ Script.parse(script, line, offset, @options[:filename])
+ end
+ end
+end