` element with the given class.
+ DIV_CLASS = ?.
+
+ # Designates a `
` 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 `%p no!`, because `else`
+ # 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).|\\.)*\2/
+
+ private
+
+ # Returns the precompiled string with the preamble and postamble
+ def precompiled_with_ambles(local_names)
+ preamble = < 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 `@precompiled`.
+ 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(< 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
+
+ # If the text is a silent script text with one of Ruby's mid-block keywords,
+ # returns the name of that keyword.
+ # Otherwise, returns nil.
+ def mid_block_keyword?(text)
+ text[MID_BLOCK_KEYWORD_REGEX, 1]
+ end
+
+ # Evaluates `text` 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 `text` to `@buffer` 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 `text` to `@buffer` 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]
+ "_hamlout.buffer << \"#{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)
+ options[:escape_html] = self.options[:escape_html] if options[:escape_html].nil?
+ push_script(
+ unescape_interpolation(text, :escape_html => options[:escape_html]),
+ :escape_html => false)
+ else
+ push_text text
+ end
+ end
+
+ # Adds +text+ to `@buffer` while flattening text.
+ def push_flat(line)
+ text = line.full.dup
+ text = "" unless text.gsub!(/^#{@flat_spaces}/, '')
+ @filter_buffer << "#{text}\n"
+ end
+
+ # Causes `text` to be evaluated in the context of
+ # the scope object and the result to be added to `@buffer`.
+ #
+ # If `opts[:preserve_script]` is true, Haml::Helpers#find_and_flatten is run on
+ # the result before it is added to `@buffer`
+ 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, "_hamlout.buffer << #{no_format ? "#{output_temp}.to_s;" : out}",
+ !(opts[:in_tag] || opts[:nuke_inner_whitespace] || @options[:ugly])])
+ end
+
+ # Causes `text` 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 `@to_close_stack`.
+ def close
+ tag, *rest = @to_close_stack.pop
+ send("close_#{tag}", *rest)
+ end
+
+ # Puts a line in `@precompiled` 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("" + (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(_1, _2, push_end = true)
+ push_silent("end", true) if push_end
+ @template_tabs -= 1
+ end
+
+ # Closes a comment.
+ def close_comment(has_conditional)
+ @output_tabs -= 1
+ @template_tabs -= 1
+ close_tag = has_conditional ? "" : "-->"
+ 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(*args)
+ @template_tabs -= 1
+ end
+
+ # Iterates through the classes and ids supplied through `.`
+ # and `#` 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)
+ return unless scanner.scan(/\s*(?:,|$)\s*/)
+ attributes[eval(key).to_s] = eval(value).to_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 `@precompiled`.
+ 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]
+
+ escape_html = (action == '&' || (action != '!' && @options[:escape_html]))
+
+ case action
+ when '/'; self_closing = true
+ when '~'; parse = preserve_script = true
+ when '='
+ parse = true
+ if value[0] == ?=
+ value = unescape_interpolation(value[1..-1].strip, :escape_html => escape_html)
+ escape_html = false
+ end
+ when '&', '!'
+ if value[0] == ?= || value[0] == ?~
+ parse = true
+ preserve_script = (value[0] == ?~)
+ if value[1] == ?=
+ value = unescape_interpolation(value[2..-1].strip, :escape_html => escape_html)
+ escape_html = false
+ else
+ value = value[1..-1].strip
+ end
+ elsif contains_interpolation?(value)
+ value = unescape_interpolation(value, :escape_html => escape_html)
+ parse = true
+ escape_html = false
+ end
+ else
+ if contains_interpolation?(value)
+ value = unescape_interpolation(value, :escape_html => escape_html)
+ parse = true
+ escape_html = false
+ end
+ end
+
+ if parse && @options[:suppress_eval]
+ parse = false
+ value = ''
+ end
+
+ 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) )
+ value = nil if value.empty? && (block_opened? || self_closing)
+
+ 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}"
+ 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 = parse ? 'nil' : value.inspect
+ 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.nil?
+ 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("" + (nuke_outer_whitespace ? "" : "\n"))
+ end
+ end
+
+ # Renders a line that creates an XHTML tag and has an implicit div because of
+ # `.` or `#`.
+ 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 = "" : "-->"}")
+ 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 ""
+ end
+
+ if html5?
+ ''
+ else
+ version, type = text.scan(DOCTYPE_REGEX)[0]
+
+ if xhtml?
+ if version == "1.1"
+ ''
+ elsif version == "5"
+ ''
+ else
+ case type
+ when "strict"; ''
+ when "frameset"; ''
+ when "mobile"; ''
+ when "basic"; ''
+ else ''
+ end
+ end
+
+ elsif html4?
+ case type
+ when "strict"; ''
+ when "frameset"; ''
+ else ''
+ 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, opts = {})
+ 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
+ content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
+ content = "Haml::Helpers.html_escape(#{content})" if opts[:escape_html]
+ res << '#{' + content + "}"# 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 `@to_close_stack` and increases
+ # `@template_tabs`.
+ 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
+ flush_merged_text unless @to_merge.all? {|type, *_| type == :text}
+ @precompiled << "\n" * @newlines
+ @newlines = 0
+ end
+
+ # Get rid of and whitespace at the end of the buffer
+ # or the merged text
+ def rstrip_buffer!(index = -1)
+ last = @to_merge[index]
+ if last.nil?
+ push_silent("_hamlout.rstrip!", false)
+ @dont_tab_up_next_text = true
+ return
+ end
+
+ case last.first
+ when :text
+ last[1].rstrip!
+ if last[1].empty?
+ @to_merge.slice! index
+ rstrip_buffer! index
+ end
+ when :script
+ last[1].gsub!(/\(haml_temp, (.*?)\);$/, '(haml_temp.rstrip, \1);')
+ rstrip_buffer! index - 1
+ else
+ raise SyntaxError.new("[HAML BUG] Undefined entry in Haml::Precompiler@to_merge.")
+ end
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/shared.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/shared.rb
new file mode 100644
index 00000000..f031fc44
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/shared.rb
@@ -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
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/template.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/template.rb
new file mode 100644
index 00000000..1aa26a46
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/template.rb
@@ -0,0 +1,85 @@
+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 [{Symbol => Object}]
+ attr_accessor :options
+
+ # Enables integration with the Rails 2.2.5+ XSS protection,
+ # if it's available and enabled.
+ #
+ # @return [Boolean] Whether the XSS integration was enabled.
+ def try_enabling_xss_integration
+ return false unless ActionView::Base.respond_to?(:xss_safe?) && ActionView::Base.xss_safe?
+
+ Haml::Template.options[:escape_html] = true
+
+ Haml::Util.module_eval {def rails_xss_safe?; true; end}
+
+ require 'haml/helpers/xss_mods'
+ Haml::Helpers.send(:include, Haml::Helpers::XssMods)
+
+ Haml::Precompiler.module_eval do
+ def precompiled_method_return_value_with_haml_xss
+ "(#{precompiled_method_return_value_without_haml_xss}).html_safe!"
+ end
+ alias_method :precompiled_method_return_value_without_haml_xss, :precompiled_method_return_value
+ alias_method :precompiled_method_return_value, :precompiled_method_return_value_with_haml_xss
+ end
+
+ true
+ end
+ 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) || defined?(ActionView::Template::Handler)
+ require 'haml/template/plugin'
+else
+ require 'haml/template/patch'
+end
+
+# Enable XSS integration. Use Rails' after_initialize method if possible
+# so that integration will be checked after the rails_xss plugin is loaded
+# (for Rails 2.3.* where it's not enabled by default).
+if defined?(Rails.configuration.after_initialize)
+ Rails.configuration.after_initialize {Haml::Template.try_enabling_xss_integration}
+else
+ Haml::Template.try_enabling_xss_integration
+end
+
+if Haml::Util.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(Haml::Util.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 < 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
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/template/plugin.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/template/plugin.rb
new file mode 100644
index 00000000..a270a38c
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/template/plugin.rb
@@ -0,0 +1,75 @@
+# This file makes Haml work with Rails
+# using the > 2.0.1 template handler API.
+
+module Haml
+ class Plugin < Haml::Util.av_template_class(:Handler)
+ if defined?(ActionView::TemplateHandlers::Compilable) ||
+ defined?(ActionView::Template::Handlers::Compilable)
+ include Haml::Util.av_template_class(:Handlers)::Compilable
+ end
+
+ 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 defined?(ActionView::TemplateError) &&
+ 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
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/util.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/util.rb
new file mode 100644
index 00000000..4cf37213
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/util.rb
@@ -0,0 +1,289 @@
+require 'erb'
+require 'set'
+require 'enumerator'
+require 'stringio'
+
+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.dirname(File.dirname(File.expand_path(__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] 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
+
+ # Silence all output to STDERR within a block.
+ #
+ # @yield A block in which no output will be printed to STDERR
+ def silence_warnings
+ the_real_stderr, $stderr = $stderr, StringIO.new
+ yield
+ ensure
+ $stderr = the_real_stderr
+ end
+
+ ## Cross Rails Version Compatibility
+
+ # Returns the root of the Rails application,
+ # if this is running in a Rails context.
+ # Returns `nil` if no such root is defined.
+ #
+ # @return [String, nil]
+ def rails_root
+ return Rails.root.to_s if defined?(Rails.root)
+ return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
+ return nil
+ end
+
+ # Returns an ActionView::Template* class.
+ # In pre-3.0 versions of Rails, most of these classes
+ # were of the form `ActionView::TemplateFoo`,
+ # while afterwards they were of the form `ActionView;:Template::Foo`.
+ #
+ # @param name [#to_s] The name of the class to get.
+ # For example, `:Error` will return `ActionView::TemplateError`
+ # or `ActionView::Template::Error`.
+ def av_template_class(name)
+ return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
+ return ActionView::Template.const_get(name.to_s)
+ end
+
+ ## Rails XSS Safety
+
+ # Whether or not ActionView's XSS protection is available and enabled,
+ # as is the default for Rails 3.0+, and optional for version 2.3.5+.
+ # Overridden in haml/template.rb if this is the case.
+ #
+ # @return [Boolean]
+ def rails_xss_safe?
+ false
+ end
+
+ # Assert that a given object (usually a String) is HTML safe
+ # according to Rails' XSS handling, if it's loaded.
+ #
+ # @param text [Object]
+ def assert_html_safe!(text)
+ return unless rails_xss_safe? && text && !text.to_s.html_safe?
+ raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
+ end
+
+ ## Cross-Ruby-Version Compatibility
+
+ # 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
+
+ ## Static Method Stuff
+
+ # 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, <
+ # 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] The names of the arguments to the defined methods
+ # (**not** to the ERB template)
+ # @param vars [Array] 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(<] 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
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/version.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/version.rb
new file mode 100644
index 00000000..de0b0017
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/haml/version.rb
@@ -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 [{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
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass.rb
new file mode 100644
index 00000000..c8243796
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass.rb
@@ -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)
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/css.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/css.rb
new file mode 100644
index 00000000..43929848
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/css.rb
@@ -0,0 +1,404 @@
+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 [{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 = {})
+ name = rules.first
+ name = "\\" + name if name[0] == ?:
+ str = "\n#{' ' * tabs}#{name}#{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(<`
+ # : 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`
+ # : 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 `name: prop`.
+ PROPERTY_NEW_MATCHER = /^[^\s:"\[]+\s*[=:](\s|$)/
+
+ # The regex that matches and extracts data from
+ # properties of the form `name: prop`.
+ PROPERTY_NEW = /^([^\s=:"]+)(\s*=|:)(?:\s+|$)(.*)/
+
+ # The regex that matches and extracts data from
+ # properties of the form `:name prop`.
+ 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 [{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.reject {|k, v| v.nil?})
+ @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(<= 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) ? < 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 '"
+ else
+ expected = "'to ' or 'through '"
+ 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 '.", @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
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/environment.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/environment.rb
new file mode 100644
index 00000000..5440c213
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/environment.rb
@@ -0,0 +1,79 @@
+module Sass
+ # The lexical environment for SassScript.
+ # This keeps track of variable and mixin definitions.
+ #
+ # A new environment is created for each level of Sass nesting.
+ # This allows variables to be lexically scoped.
+ # The new environment refers to the environment in the upper scope,
+ # so it has access to variables defined in enclosing scopes,
+ # but new variables are defined locally.
+ #
+ # Environment also keeps track of the {Engine} options
+ # so that they can be made available to {Sass::Script::Functions}.
+ class Environment
+ # The enclosing environment,
+ # or nil if this is the global environment.
+ #
+ # @return [Environment]
+ attr_reader :parent
+ attr_writer :options
+
+ # @param parent [Environment] See \{#parent}
+ def initialize(parent = nil)
+ @vars = {}
+ @mixins = {}
+ @parent = parent
+
+ set_var("important", Script::String.new("!important")) unless @parent
+ end
+
+ # The options hash.
+ # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+ #
+ # @return [{Symbol => Object}]
+ def options
+ @options || (parent && parent.options) || {}
+ end
+
+ class << self
+ private
+
+ # Note: when updating this,
+ # update haml/yard/inherited_hash.rb as well.
+ def inherited_hash(name)
+ class_eval < Object}] The options hash.
+ # Only the {file:SASS_REFERENCE.md#cache-option `:cache_location`} option is used
+ # @raise [Sass::SyntaxError] if there's an error in the document
+ def tree_for(filename, options)
+ options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
+ text = File.read(filename)
+
+ if options[:cache]
+ compiled_filename = sassc_filename(filename, options)
+ sha = Digest::SHA1.hexdigest(text)
+
+ if root = try_to_read_sassc(filename, compiled_filename, sha)
+ root.options = options.merge(:filename => filename)
+ return root
+ end
+ end
+
+ engine = Sass::Engine.new(text, options.merge(:filename => filename))
+
+ begin
+ root = engine.to_tree
+ rescue Sass::SyntaxError => err
+ err.add_backtrace_entry(filename)
+ raise err
+ end
+
+ try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
+
+ root
+ end
+
+ # Find the full filename of a Sass or CSS file to import.
+ # This follows Sass's import rules:
+ # if the filename given ends in `".sass"` or `".css"`,
+ # it will try to find that type of file;
+ # otherwise, it will try to find the corresponding Sass file
+ # and fall back on CSS if it's not available.
+ #
+ # Any Sass filename returned will correspond to
+ # an actual Sass file on the filesystem.
+ # CSS filenames, however, may not;
+ # they're expected to be put through directly to the stylesheet
+ # as CSS `@import` statements.
+ #
+ # @param filename [String] The filename to search for
+ # @param load_paths [Array] The set of filesystem paths
+ # to search for Sass files.
+ # @return [String] The filename of the imported file.
+ # This is an absolute path if the file is a `".sass"` file.
+ # @raise [Sass::SyntaxError] if `filename` ends in ``".sass"``
+ # and no corresponding Sass file could be found.
+ def find_file_to_import(filename, load_paths)
+ was_sass = false
+ original_filename = filename
+
+ if filename[-5..-1] == ".sass"
+ filename = filename[0...-5]
+ was_sass = true
+ elsif filename[-4..-1] == ".css"
+ return filename
+ end
+
+ new_filename = find_full_path("#{filename}.sass", load_paths)
+
+ return new_filename if new_filename
+ unless was_sass
+ warn < e
+ warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
+ end
+
+ def try_to_write_sassc(root, compiled_filename, sha, options)
+ return unless File.writable?(File.dirname(options[:cache_location]))
+ return if File.exists?(options[:cache_location]) && !File.writable?(options[:cache_location])
+ return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
+ return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
+ FileUtils.mkdir_p(File.dirname(compiled_filename))
+ File.open(compiled_filename, "wb") do |f|
+ f.write(Sass::VERSION)
+ f.write("\n")
+ f.write(sha)
+ f.write("\n")
+ f.write(Marshal.dump(root))
+ end
+ end
+
+ def find_full_path(filename, load_paths)
+ partial_name = File.join(File.dirname(filename), "_#{File.basename(filename)}")
+
+ if Pathname.new(filename).absolute?
+ [partial_name, filename].each do |name|
+ return name if File.readable?(name)
+ end
+ return nil
+ end
+
+ load_paths.each do |path|
+ [partial_name, filename].each do |name|
+ full_path = File.join(path, name)
+ if File.readable?(full_path)
+ return full_path
+ end
+ end
+ end
+ nil
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin.rb
new file mode 100644
index 00000000..5339e7f9
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin.rb
@@ -0,0 +1,222 @@
+require 'sass'
+
+module Sass
+ # This module handles the compilation of Sass files.
+ # It provides global options and checks whether CSS files
+ # need to be updated.
+ #
+ # This module is used as the primary interface with Sass
+ # when it's used as a plugin for various frameworks.
+ # All Rack-enabled frameworks are supported out of the box.
+ # The plugin is {file:SASS_REFERENCE.md#rails_merb_plugin automatically activated for Rails and Merb}.
+ # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
+ module Plugin
+ extend self
+
+ @options = {
+ :css_location => './public/stylesheets',
+ :always_update => false,
+ :always_check => true,
+ :full_exception => true
+ }
+ @checked_for_updates = false
+
+ # Whether or not Sass has **ever** checked if the stylesheets need to be updated
+ # (in this Ruby instance).
+ #
+ # @return [Boolean]
+ attr_reader :checked_for_updates
+
+ # An options hash.
+ # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+ #
+ # @return [{Symbol => Object}]
+ attr_reader :options
+
+ # Sets the options hash.
+ # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+ #
+ # @param value [{Symbol => Object}] The options hash
+ def options=(value)
+ @options.merge!(value)
+ end
+
+ # Non-destructively modifies \{#options} so that default values are properly set.
+ #
+ # @param additional_options [{Symbol => Object}] An options hash with which to merge \{#options}
+ # @return [{Symbol => Object}] The modified options hash
+ def engine_options(additional_options = {})
+ opts = options.dup.merge(additional_options)
+ opts[:load_paths] = load_paths(opts)
+ opts
+ end
+
+ # Same as \{#update\_stylesheets}, but respects \{#checked\_for\_updates}
+ # and the {file:SASS_REFERENCE.md#always_update-option `:always_update`}
+ # and {file:SASS_REFERENCE.md#always_check-option `:always_check`} options.
+ #
+ # @see #update_stylesheets
+ def check_for_updates
+ return unless !Sass::Plugin.checked_for_updates ||
+ Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+ update_stylesheets
+ end
+
+ # Updates out-of-date stylesheets.
+ #
+ # Checks each Sass file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
+ # to see if it's been modified more recently than the corresponding CSS file
+ # in {file:SASS_REFERENCE.md#css_location-option} `:css_location`}.
+ # If it has, it updates the CSS file.
+ def update_stylesheets
+ return if options[:never_update]
+
+ @checked_for_updates = true
+ template_locations.zip(css_locations).each do |template_location, css_location|
+
+ Dir.glob(File.join(template_location, "**", "*.sass")).each do |file|
+ # Get the relative path to the file with no extension
+ name = file.sub(template_location.sub(/\/*$/, '/'), "")[0...-5]
+
+ if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
+ update_stylesheet(name, template_location, css_location)
+ end
+ end
+ end
+ end
+
+ private
+
+ def update_stylesheet(name, template_location, css_location)
+ css = css_filename(name, css_location)
+ File.delete(css) if File.exists?(css)
+
+ filename = template_filename(name, template_location)
+ result = begin
+ Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
+ rescue Exception => e
+ raise e unless options[:full_exception]
+ exception_string(e)
+ end
+
+ # Create any directories that might be necessary
+ mkpath(css_location, name)
+
+ # Finally, write the file
+ File.open(css, 'w') do |file|
+ file.print(result)
+ end
+ end
+
+ # Create any successive directories required to be able to write a file to: File.join(base,name)
+ def mkpath(base, name)
+ dirs = [base]
+ name.split(File::SEPARATOR)[0...-1].each { |dir| dirs << File.join(dirs[-1],dir) }
+ dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
+ end
+
+ def load_paths(opts = options)
+ (opts[:load_paths] || []) + template_locations
+ end
+
+ def template_locations
+ location = (options[:template_location] || File.join(options[:css_location],'sass'))
+ if location.is_a?(String)
+ [location]
+ else
+ location.to_a.map { |l| l.first }
+ end
+ end
+
+ def css_locations
+ if options[:template_location] && !options[:template_location].is_a?(String)
+ options[:template_location].to_a.map { |l| l.last }
+ else
+ [options[:css_location]]
+ end
+ end
+
+ def exception_string(e)
+ e_string = "#{e.class}: #{e.message}"
+
+ if e.is_a? Sass::SyntaxError
+ e_string << "\non line #{e.sass_line}"
+
+ if e.sass_filename
+ e_string << " of #{e.sass_filename}"
+
+ if File.exists?(e.sass_filename)
+ e_string << "\n\n"
+
+ min = [e.sass_line - 5, 0].max
+ begin
+ File.read(e.sass_filename).rstrip.split("\n")[
+ min .. e.sass_line + 5
+ ].each_with_index do |line, i|
+ e_string << "#{min + i + 1}: #{line}\n"
+ end
+ rescue
+ e_string << "Couldn't read sass file: #{e.sass_filename}"
+ end
+ end
+ end
+ end
+ < css_mtime ||
+ dependencies(template_file).any?(&dependency_updated?(css_mtime))
+ end
+
+ def dependency_updated?(css_mtime)
+ lambda do |dep|
+ File.mtime(dep) > css_mtime ||
+ dependencies(dep).any?(&dependency_updated?(css_mtime))
+ end
+ end
+
+ def dependencies(filename)
+ File.readlines(filename).grep(/^@import /).map do |line|
+ line[8..-1].split(',').map do |inc|
+ Sass::Files.find_file_to_import(inc.strip, [File.dirname(filename)] + load_paths)
+ end
+ end.flatten.grep(/\.sass$/)
+ end
+ end
+end
+
+require 'sass/plugin/rails' if defined?(ActionController)
+require 'sass/plugin/merb' if defined?(Merb::Plugins)
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/merb.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/merb.rb
new file mode 100644
index 00000000..fb931f37
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/merb.rb
@@ -0,0 +1,49 @@
+unless defined?(Sass::MERB_LOADED)
+ Sass::MERB_LOADED = true
+
+ version = Merb::VERSION.split('.').map { |n| n.to_i }
+ if version[0] <= 0 && version[1] < 5
+ root = MERB_ROOT
+ env = MERB_ENV
+ else
+ root = Merb.root.to_s
+ env = Merb.environment
+ end
+
+ Sass::Plugin.options.merge!(:template_location => root + '/public/stylesheets/sass',
+ :css_location => root + '/public/stylesheets',
+ :cache_location => root + '/tmp/sass-cache',
+ :always_check => env != "production",
+ :full_exception => env != "production")
+ config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
+
+ if defined? config.symbolize_keys!
+ config.symbolize_keys!
+ end
+
+ Sass::Plugin.options.merge!(config)
+
+ if version[0] > 0 || version[1] >= 9
+
+ class Merb::Rack::Application
+ def call_with_sass(env)
+ Sass::Plugin.check_for_updates
+ call_without_sass(env)
+ end
+ alias_method :call_without_sass, :call
+ alias_method :call, :call_with_sass
+ end
+
+ else
+
+ class MerbHandler
+ def process_with_sass(request, response)
+ Sass::Plugin.check_for_updates
+ process_without_sass(request, response)
+ end
+ alias_method :process_without_sass, :process
+ alias_method :process, :process_with_sass
+ end
+
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/rack.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/rack.rb
new file mode 100644
index 00000000..9275b4ba
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/rack.rb
@@ -0,0 +1,65 @@
+require 'sass/plugin'
+
+module Sass
+ module Plugin
+ # Rack middleware for compiling Sass code.
+ #
+ # ## Activate
+ #
+ # require 'sass/plugin/rack'
+ # use Sass::Plugin::Rack
+ #
+ # ## Customize
+ #
+ # Sass::Plugin.options.merge(
+ # :cache_location => './tmp/sass-cache',
+ # :never_update => environment != :production,
+ # :full_exception => environment != :production)
+ #
+ # {file:SASS_REFERENCE.md#options See the Reference for more options}.
+ #
+ # ## Use
+ #
+ # Put your Sass files in `public/stylesheets/sass`.
+ # Your CSS will be generated in `public/stylesheets`,
+ # and regenerated every request if necessary.
+ # The locations and frequency {file:SASS_REFERENCE.md#options can be customized}.
+ # That's all there is to it!
+ class Rack
+ # Initialize the middleware.
+ #
+ # @param app [#call] The Rack application
+ def initialize(app)
+ @app = app
+ self.class.disable_native_plugin!
+ end
+
+ # Process a request, checking the Sass stylesheets for changes
+ # and updating them if necessary.
+ #
+ # @param env The Rack request environment
+ # @return [(#to_i, {String => String}, Object)] The Rack response
+ def call(env)
+ Sass::Plugin.check_for_updates
+ @app.call(env)
+ end
+
+ # Disable the native Rails or Merb plugins, if they're enabled.
+ # This is automatically done once the Rack plugin is activated.
+ # This is done so that the stylesheets aren't checked twice for each request.
+ def self.disable_native_plugin!
+ if defined?(Merb::Rack::Application) &&
+ Haml::Util.has?(:instance_method, Merb::Rack::Application, :call_without_sass)
+ Merb::Rack::Application.instance_eval {alias_method :call, :call_without_sass}
+ end
+
+ if defined?(ActionDispatch::Callbacks.to_prepare)
+ ActionDispatch::Callbacks.skip_callback(:prepare, :__sass_process)
+ elsif defined?(ActionController::Base) &&
+ Haml::Util.has?(:instance_method, ActionController::Base, :sass_old_process)
+ ActionController::Base.instance_eval {alias_method :process, :sass_old_process}
+ end
+ end
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/rails.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/rails.rb
new file mode 100644
index 00000000..8d4a5f40
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/plugin/rails.rb
@@ -0,0 +1,24 @@
+unless defined?(Sass::RAILS_LOADED)
+ Sass::RAILS_LOADED = true
+
+ Sass::Plugin.options.merge!(:template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
+ :css_location => Haml::Util.rails_root + '/public/stylesheets',
+ :cache_location => Haml::Util.rails_root + '/tmp/sass-cache',
+ :always_check => RAILS_ENV != "production",
+ :full_exception => RAILS_ENV != "production")
+
+ if defined?(ActionDispatch::Callbacks.to_prepare)
+ # Rails >= 3.0.0
+ ActionDispatch::Callbacks.to_prepare(:sass_process) {Sass::Plugin.check_for_updates}
+ else
+ module ActionController
+ class Base
+ alias_method :sass_old_process, :process
+ def process(*args)
+ Sass::Plugin.check_for_updates
+ sass_old_process(*args)
+ end
+ end
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/repl.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/repl.rb
new file mode 100644
index 00000000..ee955bf8
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/repl.rb
@@ -0,0 +1,58 @@
+require 'readline'
+
+module Sass
+ # Runs a SassScript read-eval-print loop.
+ # It presents a prompt on the terminal,
+ # reads in SassScript expressions,
+ # evaluates them,
+ # and prints the result.
+ class Repl
+ # @param options [{Symbol => Object}] An options hash.
+ def initialize(options = {})
+ @options = options
+ end
+
+ # Starts the read-eval-print loop.
+ def run
+ environment = Environment.new
+ environment.set_var('important', Script::String.new('!important'))
+ @line = 0
+ loop do
+ @line += 1
+ unless text = Readline.readline('>> ')
+ puts
+ return
+ end
+
+ Readline::HISTORY << text
+ parse_input(environment, text)
+ end
+ end
+
+ private
+
+ def parse_input(environment, text)
+ case text
+ when Script::MATCH
+ name = $1
+ guarded = $2 == '||='
+ val = Script::Parser.parse($3, @line, text.size - $3.size)
+
+ unless guarded && environment.var(name)
+ environment.set_var(name, val.perform(environment))
+ end
+
+ p environment.var(name)
+ else
+ p Script::Parser.parse(text, @line, 0).perform(environment)
+ end
+ rescue Sass::SyntaxError => e
+ puts "SyntaxError: #{e.message}"
+ if @options[:trace]
+ e.backtrace.each do |e|
+ puts "\tfrom #{e}"
+ end
+ end
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script.rb
new file mode 100644
index 00000000..bcacabd8
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script.rb
@@ -0,0 +1,59 @@
+require 'strscan'
+require 'sass/script/node'
+require 'sass/script/variable'
+require 'sass/script/funcall'
+require 'sass/script/operation'
+require 'sass/script/literal'
+require 'sass/script/parser'
+
+module Sass
+ # SassScript is code that's embedded in Sass documents
+ # to allow for property values to be computed from variables.
+ #
+ # This module contains code that handles the parsing and evaluation of SassScript.
+ module Script
+ # The character that begins a variable.
+ VARIABLE_CHAR = ?!
+
+ # The regular expression used to parse variables.
+ MATCH = /^!([a-zA-Z_]\w*)\s*((?:\|\|)?=)\s*(.+)/
+
+ # The regular expression used to validate variables without matching.
+ VALIDATE = /^![a-zA-Z_]\w*$/
+
+ # Parses and evaluates a string of SassScript.
+ #
+ # @param value [String] The SassScript
+ # @param line [Fixnum] The number of the line on which the SassScript appeared.
+ # Used for error reporting
+ # @param offset [Fixnum] The number of characters in on `line` that the SassScript started.
+ # Used for error reporting
+ # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+ # @return [String] The string result of evaluating the SassScript
+ def self.resolve(value, line, offset, environment)
+ parse(value, line, offset).perform(environment).to_s
+ end
+
+ # Parses a string of SassScript
+ #
+ # @param value [String] The SassScript
+ # @param line [Fixnum] The number of the line on which the SassScript appeared.
+ # Used for error reporting
+ # @param offset [Fixnum] The number of characters in on `line` that the SassScript started.
+ # Used for error reporting
+ # @param filename [String] The path to the file in which the SassScript appeared.
+ # Used for error reporting
+ # @return [Script::Node] The root node of the parse tree
+ def self.parse(value, line, offset, filename = nil)
+ Parser.parse(value, line, offset, filename)
+ rescue Sass::SyntaxError => e
+ if e.message == "SassScript error"
+ e.instance_eval do
+ @message += ": #{value.dump}."
+ end
+ end
+ e.sass_line = line
+ raise e
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/bool.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/bool.rb
new file mode 100644
index 00000000..0f455dbd
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/bool.rb
@@ -0,0 +1,17 @@
+require 'sass/script/literal'
+
+module Sass::Script
+ # A SassScript object representing a boolean (true or false) value.
+ class Bool < Literal
+ # The Ruby value of the boolean.
+ #
+ # @return [Boolean]
+ attr_reader :value
+ alias_method :to_bool, :value
+
+ # @return [String] "true" or "false"
+ def to_s
+ @value.to_s
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/color.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/color.rb
new file mode 100644
index 00000000..6e1cce11
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/color.rb
@@ -0,0 +1,220 @@
+require 'sass/script/literal'
+
+module Sass::Script
+ # A SassScript object representing a CSS color.
+ class Color < Literal
+ class << self; include Haml::Util; end
+
+ # A hash from color names to `[red, green, blue]` value arrays.
+ HTML4_COLORS = map_vals({
+ 'black' => 0x000000,
+ 'silver' => 0xc0c0c0,
+ 'gray' => 0x808080,
+ 'white' => 0xffffff,
+ 'maroon' => 0x800000,
+ 'red' => 0xff0000,
+ 'purple' => 0x800080,
+ 'fuchsia' => 0xff00ff,
+ 'green' => 0x008000,
+ 'lime' => 0x00ff00,
+ 'olive' => 0x808000,
+ 'yellow' => 0xffff00,
+ 'navy' => 0x000080,
+ 'blue' => 0x0000ff,
+ 'teal' => 0x008080,
+ 'aqua' => 0x00ffff
+ }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
+ # A hash from `[red, green, blue]` value arrays to color names.
+ HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
+
+ # Creates a new color from RGB components.
+ # *Note*: when modifying the components of an existing color,
+ # use \{#with} rather than creating a new color object.
+ # This preserves forwards-compatiblity for alpha channels and such.
+ #
+ # @param rgb [Array] A three-element array of the red, green, and blue values (respectively)
+ # of the color
+ # @raise [Sass::SyntaxError] if any color value isn't between 0 and 255
+ def initialize(rgb)
+ rgb = rgb.map {|c| c.to_i}
+ raise Sass::SyntaxError.new("Color values must be between 0 and 255") if rgb.any? {|c| c < 0 || c > 255}
+ super(rgb.freeze)
+ end
+
+ # @deprecated This will be removed in version 2.6.
+ # @see #rgb
+ def value
+ warn <] A frozen three-element array of the red, green, and blue
+ # values (respectively) of the color
+ def rgb
+ @value
+ end
+
+ # Returns a copy of this color with one or more channels changed.
+ #
+ # For example:
+ #
+ # Color.new([10, 20, 30]).with(:blue => 40)
+ # #=> rgb(10, 40, 30)
+ # Color.new([126, 126, 126]).with(:red => 0, :green => 255)
+ # #=> rgb(0, 255, 126)
+ #
+ # @param attrs [{Symbol => Fixnum}]
+ # A map of channel names (`:red`, `:green`, or `:blue`) to values
+ # @return [Color] The new Color object
+ def with(attrs)
+ Color.new([
+ attrs[:red] || rgb[0],
+ attrs[:green] || rgb[1],
+ attrs[:blue] || rgb[2],
+ ])
+ end
+
+ # The SassScript `+` operation.
+ # Its functionality depends on the type of its argument:
+ #
+ # {Number}
+ # : Adds the number to each of the RGB color channels.
+ #
+ # {Color}
+ # : Adds each of the RGB color channels together.
+ #
+ # {Literal}
+ # : See {Literal#plus}.
+ #
+ # @param other [Literal] The right-hand side of the operator
+ # @return [Color] The resulting color
+ # @raise [Sass::SyntaxError] if `other` is a number with units
+ def plus(other)
+ if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+ piecewise(other, :+)
+ else
+ super
+ end
+ end
+
+ # The SassScript `-` operation.
+ # Its functionality depends on the type of its argument:
+ #
+ # {Number}
+ # : Subtracts the number from each of the RGB color channels.
+ #
+ # {Color}
+ # : Subtracts each of the other color's RGB color channels from this color's.
+ #
+ # {Literal}
+ # : See {Literal#minus}.
+ #
+ # @param other [Literal] The right-hand side of the operator
+ # @return [Color] The resulting color
+ # @raise [Sass::SyntaxError] if `other` is a number with units
+ def minus(other)
+ if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+ piecewise(other, :-)
+ else
+ super
+ end
+ end
+
+ # The SassScript `*` operation.
+ # Its functionality depends on the type of its argument:
+ #
+ # {Number}
+ # : Multiplies the number by each of the RGB color channels.
+ #
+ # {Color}
+ # : Multiplies each of the RGB color channels together.
+ #
+ # @param other [Number, Color] The right-hand side of the operator
+ # @return [Color] The resulting color
+ # @raise [Sass::SyntaxError] if `other` is a number with units
+ def times(other)
+ if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+ piecewise(other, :*)
+ else
+ raise NoMethodError.new(nil, :times)
+ end
+ end
+
+ # The SassScript `/` operation.
+ # Its functionality depends on the type of its argument:
+ #
+ # {Number}
+ # : Divides each of the RGB color channels by the number.
+ #
+ # {Color}
+ # : Divides each of this color's RGB color channels by the other color's.
+ #
+ # {Literal}
+ # : See {Literal#div}.
+ #
+ # @param other [Literal] The right-hand side of the operator
+ # @return [Color] The resulting color
+ # @raise [Sass::SyntaxError] if `other` is a number with units
+ def div(other)
+ if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+ piecewise(other, :/)
+ else
+ super
+ end
+ end
+
+ # The SassScript `%` operation.
+ # Its functionality depends on the type of its argument:
+ #
+ # {Number}
+ # : Takes each of the RGB color channels module the number.
+ #
+ # {Color}
+ # : Takes each of this color's RGB color channels modulo the other color's.
+ #
+ # @param other [Number, Color] The right-hand side of the operator
+ # @return [Color] The resulting color
+ # @raise [Sass::SyntaxError] if `other` is a number with units
+ def mod(other)
+ if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+ piecewise(other, :%)
+ else
+ raise NoMethodError.new(nil, :mod)
+ end
+ end
+
+ # Returns a string representation of the color.
+ # This is usually the color's hex value,
+ # but if the color has a name that's used instead.
+ #
+ # @return [String] The string representation
+ def to_s
+ return HTML4_COLORS_REVERSE[rgb] if HTML4_COLORS_REVERSE[rgb]
+ red, green, blue = rgb.map { |num| num.to_s(16).rjust(2, '0') }
+ "##{red}#{green}#{blue}"
+ end
+ alias_method :inspect, :to_s
+
+ private
+
+ def piecewise(other, operation)
+ other_num = other.is_a? Number
+ if other_num && !other.unitless?
+ raise Sass::SyntaxError.new("Cannot add a number with units (#{other}) to a color (#{self}).")
+ end
+
+ result = []
+ for i in (0...3)
+ res = rgb[i].send(operation, other_num ? other.value : other.rgb[i])
+ result[i] = [ [res, 255].min, 0 ].max
+ end
+ with(:red => result[0], :green => result[1], :blue => result[2])
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/funcall.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/funcall.rb
new file mode 100644
index 00000000..7e144cf1
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/funcall.rb
@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'functions')
+module Sass
+ module Script
+ # A SassScript parse node representing a function call.
+ #
+ # A function call either calls one of the functions in {Script::Functions},
+ # or if no function with the given name exists
+ # it returns a string representation of the function call.
+ class Funcall < Node
+ # The name of the function.
+ #
+ # @return [String]
+ attr_reader :name
+
+ # The arguments to the function.
+ #
+ # @return [Array]
+ attr_reader :args
+
+ # @param name [String] See \{#name}
+ # @param name [Array] See \{#args}
+ def initialize(name, args)
+ @name = name
+ @args = args
+ end
+
+ # @return [String] A string representation of the function call
+ def inspect
+ "#{name}(#{args.map {|a| a.inspect}.join(', ')})"
+ end
+
+ # Evaluates the function call.
+ #
+ # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+ # @return [Literal] The SassScript object that is the value of the function call
+ # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
+ def perform(environment)
+ args = self.args.map {|a| a.perform(environment)}
+ unless Haml::Util.has?(:public_instance_method, Functions, name) && name !~ /^__/
+ return Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})")
+ end
+
+ return Functions::EvaluationContext.new(environment.options).send(name, *args)
+ rescue ArgumentError => e
+ raise e unless e.backtrace.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
+ raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
+ end
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/functions.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/functions.rb
new file mode 100644
index 00000000..fef69602
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/functions.rb
@@ -0,0 +1,257 @@
+module Sass::Script
+ # Methods in this module are accessible from the SassScript context.
+ # For example, you can write
+ #
+ # !color = hsl(120, 100%, 50%)
+ #
+ # and it will call {Sass::Script::Functions#hsl}.
+ #
+ # The following functions are provided:
+ #
+ # \{#hsl}
+ # : Converts an `hsl(hue, saturation, lightness)` triplet into a color.
+ #
+ # \{#rgb}
+ # : Converts an `rgb(red, green, blue)` triplet into a color.
+ #
+ # \{#percentage}
+ # : Converts a unitless number to a percentage.
+ #
+ # \{#round}
+ # : Rounds a number to the nearest whole number.
+ #
+ # \{#ceil}
+ # : Rounds a number up to the nearest whole number.
+ #
+ # \{#floor}
+ # : Rounds a number down to the nearest whole number.
+ #
+ # \{#abs}
+ # : Returns the absolute value of a number.
+ #
+ # These functions are described in more detail below.
+ #
+ # ## Adding Custom Functions
+ #
+ # New Sass functions can be added by adding Ruby methods to this module.
+ # For example:
+ #
+ # module Sass::Script::Functions
+ # def reverse(string)
+ # assert_type string, :String
+ # Sass::Script::String.new(string.value.reverse)
+ # end
+ # end
+ #
+ # There are a few things to keep in mind when modifying this module.
+ # First of all, the arguments passed are {Sass::Script::Literal} objects.
+ # Literal objects are also expected to be returned.
+ # This means that Ruby values must be unwrapped and wrapped.
+ #
+ # Most Literal objects support the {Sass::Script::Literal#value value} accessor
+ # for getting their Ruby values.
+ # Color objects, though, must be accessed using {Sass::Script::Color#rgb rgb}.
+ #
+ # Second, making Ruby functions accessible from Sass introduces the temptation
+ # to do things like database access within stylesheets.
+ # This is generally a bad idea;
+ # since Sass files are by default only compiled once,
+ # dynamic code is not a great fit.
+ #
+ # If you really, really need to compile Sass on each request,
+ # first make sure you have adequate caching set up.
+ # Then you can use {Sass::Engine} to render the code,
+ # using the {file:SASS_REFERENCE.md#custom-option `options` parameter}
+ # to pass in data that {EvaluationContext#options can be accessed}
+ # from your Sass functions.
+ #
+ # Within one of the functions in this module,
+ # methods of {EvaluationContext} can be used.
+ module Functions
+ # The context in which methods in {Script::Functions} are evaluated.
+ # That means that all instance methods of {EvaluationContext}
+ # are available to use in functions.
+ class EvaluationContext
+ # The options hash for the {Sass::Engine} that is processing the function call
+ #
+ # @return [{Symbol => Object}]
+ attr_reader :options
+
+ # @param options [{Symbol => Object}] See \{#options}
+ def initialize(options)
+ @options = options
+
+ # We need to include this individually in each instance
+ # because of an icky Ruby restriction
+ class << self; include Sass::Script::Functions; end
+ end
+
+ # Asserts that the type of a given SassScript value
+ # is the expected type (designated by a symbol).
+ # For example:
+ #
+ # assert_type value, :String
+ # assert_type value, :Number
+ #
+ # Valid types are `:Bool`, `:Color`, `:Number`, and `:String`.
+ #
+ # @param value [Sass::Script::Literal] A SassScript value
+ # @param type [Symbol] The name of the type the value is expected to be
+ def assert_type(value, type)
+ return if value.is_a?(Sass::Script.const_get(type))
+ raise ArgumentError.new("#{value.inspect} is not a #{type.to_s.downcase}")
+ end
+ end
+
+ instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
+
+
+ # Creates a {Color} object from red, green, and blue values.
+ # @param red
+ # A number between 0 and 255 inclusive,
+ # or between 0% and 100% inclusive
+ # @param green
+ # A number between 0 and 255 inclusive,
+ # or between 0% and 100% inclusive
+ # @param blue
+ # A number between 0 and 255 inclusive,
+ # or between 0% and 100% inclusive
+ def rgb(red, green, blue)
+ assert_type red, :Number
+ assert_type green, :Number
+ assert_type blue, :Number
+
+ rgb = [red, green, blue].map do |c|
+ v = c.value
+ if c.numerator_units == ["%"] && c.denominator_units.empty?
+ next v * 255 / 100.0 if (0..100).include?(v)
+ raise ArgumentError.new("Color value #{c} must be between 0% and 100% inclusive")
+ else
+ next v if (0..255).include?(v)
+ raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
+ end
+ end
+ Color.new(rgb)
+ end
+
+ # Creates a {Color} object from hue, saturation, and lightness.
+ # Uses the algorithm from the [CSS3 spec](http://www.w3.org/TR/css3-color/#hsl-color).
+ #
+ # @param hue [Number] The hue of the color.
+ # Should be between 0 and 360 degrees, inclusive
+ # @param saturation [Number] The saturation of the color.
+ # Must be between `0%` and `100%`, inclusive
+ # @param lightness [Number] The lightness of the color.
+ # Must be between `0%` and `100%`, inclusive
+ # @return [Color] The resulting color
+ # @raise [ArgumentError] if `saturation` or `lightness` are out of bounds
+ def hsl(hue, saturation, lightness)
+ assert_type hue, :Number
+ assert_type saturation, :Number
+ assert_type lightness, :Number
+
+ original_s = saturation
+ original_l = lightness
+ # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
+ h, s, l = [hue, saturation, lightness].map { |a| a.value }
+ raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") if s < 0 || s > 100
+ raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") if l < 0 || l > 100
+
+ h = (h % 360) / 360.0
+ s /= 100.0
+ l /= 100.0
+
+ m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s
+ m1 = l * 2 - m2
+ Color.new([hue_to_rgb(m1, m2, h + 1.0/3),
+ hue_to_rgb(m1, m2, h),
+ hue_to_rgb(m1, m2, h - 1.0/3)].map { |c| (c * 0xff).round })
+ end
+
+ # Converts a decimal number to a percentage.
+ # For example:
+ #
+ # percentage(100px / 50px) => 200%
+ #
+ # @param value [Number] The decimal number to convert to a percentage
+ # @return [Number] The percentage
+ # @raise [ArgumentError] If `value` isn't a unitless number
+ def percentage(value)
+ unless value.is_a?(Sass::Script::Number) && value.unitless?
+ raise ArgumentError.new("#{value.inspect} is not a unitless number")
+ end
+ Sass::Script::Number.new(value.value * 100, ['%'])
+ end
+
+ # Rounds a number to the nearest whole number.
+ # For example:
+ #
+ # round(10.4px) => 10px
+ # round(10.6px) => 11px
+ #
+ # @param value [Number] The number
+ # @return [Number] The rounded number
+ # @raise [Sass::SyntaxError] if `value` isn't a number
+ def round(value)
+ numeric_transformation(value) {|n| n.round}
+ end
+
+ # Rounds a number up to the nearest whole number.
+ # For example:
+ #
+ # ciel(10.4px) => 11px
+ # ciel(10.6px) => 11px
+ #
+ # @param value [Number] The number
+ # @return [Number] The rounded number
+ # @raise [Sass::SyntaxError] if `value` isn't a number
+ def ceil(value)
+ numeric_transformation(value) {|n| n.ceil}
+ end
+
+ # Rounds down to the nearest whole number.
+ # For example:
+ #
+ # floor(10.4px) => 10px
+ # floor(10.6px) => 10px
+ #
+ # @param value [Number] The number
+ # @return [Number] The rounded number
+ # @raise [Sass::SyntaxError] if `value` isn't a number
+ def floor(value)
+ numeric_transformation(value) {|n| n.floor}
+ end
+
+ # Finds the absolute value of a number.
+ # For example:
+ #
+ # abs(10px) => 10px
+ # abs(-10px) => 10px
+ #
+ # @param value [Number] The number
+ # @return [Number] The absolute value
+ # @raise [Sass::SyntaxError] if `value` isn't a number
+ def abs(value)
+ numeric_transformation(value) {|n| n.abs}
+ end
+
+ private
+
+ # This method implements the pattern of transforming a numeric value into
+ # another numeric value with the same units.
+ # It yields a number to a block to perform the operation and return a number
+ def numeric_transformation(value)
+ assert_type value, :Number
+ Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
+ end
+
+ def hue_to_rgb(m1, m2, h)
+ h += 1 if h < 0
+ h -= 1 if h > 1
+ return m1 + (m2 - m1) * h * 6 if h * 6 < 1
+ return m2 if h * 2 < 1
+ return m1 + (m2 - m1) * (2.0/3 - h) * 6 if h * 3 < 2
+ return m1
+ end
+ end
+end
diff --git a/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/lexer.rb b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/lexer.rb
new file mode 100644
index 00000000..268331e2
--- /dev/null
+++ b/lib/middleman/vendor/gems/ruby/1.9.1/gems/haml-2.2.17/lib/sass/script/lexer.rb
@@ -0,0 +1,191 @@
+require 'strscan'
+
+module Sass
+ module Script
+ # The lexical analyzer for SassScript.
+ # It takes a raw string and converts it to individual tokens
+ # that are easier to parse.
+ class Lexer
+ # A struct containing information about an individual token.
+ #
+ # `type`: \[{Symbol}\]
+ # : The type of token.
+ #
+ # `value`: \[{Object}\]
+ # : The Ruby object corresponding to the value of the token.
+ #
+ # `line`: \[{Fixnum}\]
+ # : The line of the source file on which the token appears.
+ #
+ # `offset`: \[{Fixnum}\]
+ # : The number of bytes into the line the SassScript token appeared.
+ Token = Struct.new(:type, :value, :line, :offset)
+
+ # A hash from operator strings to the corresponding token types.
+ OPERATORS = {
+ '+' => :plus,
+ '-' => :minus,
+ '*' => :times,
+ '/' => :div,
+ '%' => :mod,
+ '=' => :single_eq,
+ '(' => :lparen,
+ ')' => :rparen,
+ ',' => :comma,
+ 'and' => :and,
+ 'or' => :or,
+ 'not' => :not,
+ '==' => :eq,
+ '!=' => :neq,
+ '>=' => :gte,
+ '<=' => :lte,
+ '>' => :gt,
+ '<' => :lt,
+ '#{' => :begin_interpolation,
+ '}' => :end_interpolation,
+ }
+
+ # A list of operator strings ordered with longer names first
+ # so that `>` and `<` don't clobber `>=` and `<=`.
+ OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
+
+ # A hash of regular expressions that are used for tokenizing.
+ REGULAR_EXPRESSIONS = {
+ :whitespace => /\s*/,
+ :variable => /!(\w+)/,
+ :ident => /(\\.|[^\s\\+\-*\/%(),=!])+/,
+ :string_end => /((?:\\.|\#(?!\{)|[^"\\#])*)(?:"|(?=#\{))/,
+ :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
+ :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})/,
+ :bool => /(true|false)\b/,
+ :op => %r{(#{Regexp.union(*OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + (s =~ /\w$/ ? '(?:\b|$)' : ''))})})}
+ }
+
+ # @param str [String, StringScanner] The source text to lex
+ # @param line [Fixnum] The line on which the SassScript appears.
+ # Used for error reporting
+ # @param offset [Fixnum] The number of characters in on which the SassScript appears.
+ # Used for error reporting
+ def initialize(str, line, offset, filename)
+ @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
+ @line = line
+ @offset = offset
+ @filename = filename
+ @prev = nil
+ end
+
+ # Moves the lexer forward one token.
+ #
+ # @return [Token] The token that was moved past
+ def next
+ @tok ||= read_token
+ @tok, tok = nil, @tok
+ @prev = tok
+ return tok
+ end
+
+ # Returns the next token without moving the lexer forward.
+ #
+ # @return [Token] The next token
+ def peek
+ @tok ||= read_token
+ end
+
+ # @return [Boolean] Whether or not there's more source text to lex.
+ def done?
+ whitespace unless after_interpolation?
+ @scanner.eos? && @tok.nil?
+ end
+
+ private
+
+ def read_token
+ return if done?
+
+ value = token
+ unless value
+ raise SyntaxError.new("Syntax error in '#{@scanner.string}' at character #{current_position}.")
+ end
+ Token.new(value.first, value.last, @line, last_match_position)
+ end
+
+ def whitespace
+ @scanner.scan(REGULAR_EXPRESSIONS[:whitespace])
+ end
+
+ def token
+ return string('') if after_interpolation?
+ variable || string || number || color || bool || op || ident
+ end
+
+ def variable
+ return unless @scanner.scan(REGULAR_EXPRESSIONS[:variable])
+ [:const, @scanner[1]]
+ end
+
+ def ident
+ return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:ident])
+ [:ident, s.gsub(/\\(.)/, '\1')]
+ end
+
+ def string(start_char = '"')
+ return unless @scanner.scan(/#{start_char}#{REGULAR_EXPRESSIONS[:string_end]}/)
+ [:string, Script::String.new(@scanner[1].gsub(/\\([^0-9a-f])/, '\1').gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1"))]
+ end
+
+ def begin_interpolation
+ @scanner.scan
+ end
+
+ def number
+ return unless @scanner.scan(REGULAR_EXPRESSIONS[:number])
+ value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
+ value = -value if @scanner[1]
+ [:number, Script::Number.new(value, Array(@scanner[4]))]
+ end
+
+ def color
+ return unless @scanner.scan(REGULAR_EXPRESSIONS[:color])
+ value = if @scanner[4]
+ color = Color::HTML4_COLORS[@scanner[4].downcase]
+ else
+ (1..3).map {|i| @scanner[i]}.map {|num| num.ljust(2, num).to_i(16)}
+ end
+ [:color, Script::Color.new(value)]
+ end
+
+ def bool
+ return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:bool])
+ [:bool, Script::Bool.new(s == 'true')]
+ end
+
+ def op
+ prev_chr = @scanner.string[@scanner.pos - 1].chr
+ return unless op = @scanner.scan(REGULAR_EXPRESSIONS[:op])
+ if @prev && op == '-' && prev_chr !~ /\s/ &&
+ [:bool, :ident, :const].include?(@prev.type)
+ warn(<
Change Password
+
+
+
+ 
Cancel
+
+
+a.button
+ // you can pass "left" or "right" to +anchor-button to float it in that direction
+ // or you can pass no argument to leave it inline-block (cross browser safe!) within
+ // the flow of your page.
+ +anchor-button("left")
+ // All the button color mixins take 4 optional arguments:
+ // font color, background color, border color, border highlight color
+ // the first three default to constants set in blueprint/buttons.sass
+ // the last one defaults to a shade lighter than the border color.
+ +button-colors
+ +button-hover-colors
+ +button-active-colors
+
+button
+ // The +button-button mixin is just like the +anchor-button mixin, but for