haml-edge 2.3.179 → 2.3.180

data/lib/haml/template.rb

@@ -77,7 +77,7 @@ if Haml::Util.rails_root
       FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
     end
   rescue SystemCallError
-    warn <<END
+    Haml::Util.haml_warn <<END
 HAML WARNING:
 #{rails_init_file} is out of date and couldn't be automatically updated.
 Please run `haml --rails #{File.expand_path(Haml::Util.rails_root)}' to update it.

data/lib/haml/util.rb

@@ -135,6 +135,18 @@ module Haml
       end
     end
 
+    # Destructively strips whitespace from the beginning and end
+    # of the first and last elements, respectively,
+    # in the array (if those elements are strings).
+    #
+    # @param arr [Array]
+    # @return [Array] `arr`
+    def strip_string_array(arr)
+      arr.first.lstrip! if arr.first.is_a?(String)
+      arr.last.rstrip! if arr.last.is_a?(String)
+      arr
+    end
+
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -156,6 +168,26 @@ module Haml
       $stderr = the_real_stderr
     end
 
+    @@silence_warnings = false
+    # Silences all Haml warnings within a block.
+    #
+    # @yield A block in which no Haml warnings will be printed
+    def silence_haml_warnings
+      old_silence_warnings = @@silence_warnings
+      @@silence_warnings = true
+      yield
+    ensure
+      @@silence_warnings = old_silence_warnings
+    end
+
+    # The same as `Kernel#warn`, but is silenced by \{#silence\_haml\_warnings}.
+    #
+    # @param msg [String]
+    def haml_warn(msg)
+      return if @@silence_warnings
+      warn(msg)
+    end
+
     ## Cross Rails Version Compatibility
 
     # Returns the root of the Rails application,
@@ -326,6 +358,24 @@ MSG
       ruby1_8? ? enum.enum_with_index : enum.each_with_index
     end
 
+    # A version of `Enumerable#enum_cons` that works in Ruby 1.8 and 1.9.
+    #
+    # @param enum [Enumerable] The enumerable to get the enumerator for
+    # @param n [Fixnum] The size of each cons
+    # @return [Enumerator] The consed enumerator
+    def enum_cons(enum, n)
+      ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
+    end
+
+    # A version of `Enumerable#enum_slice` that works in Ruby 1.8 and 1.9.
+    #
+    # @param enum [Enumerable] The enumerable to get the enumerator for
+    # @param n [Fixnum] The size of each slice
+    # @return [Enumerator] The consed enumerator
+    def enum_slice(enum, n)
+      ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
+    end
+
     # Returns the ASCII code of the given character.
     #
     # @param c [String] All characters but the first are ignored.

data/lib/sass.rb

@@ -5,7 +5,7 @@ require 'haml/version'
 
 # The module that contains everything Sass-related:
 #
-# * {Sass::Engine} is the class used to render Sass within Ruby code.
+# * {Sass::Engine} is the class used to render Sass/SCSS 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.

data/lib/sass/css.rb

@@ -1,96 +1,49 @@
 require File.dirname(__FILE__) + '/../sass'
 require 'sass/tree/node'
+require 'sass/scss/css_parser'
 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.
+  # This class converts CSS documents into Sass or SCSS 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.
+  # to produce more concise and idiomatic Sass/SCSS.
   #
   # Example usage:
   #
-  #     Sass::CSS.new("p { color: blue }").render #=> "p\n  color: blue"
+  #     Sass::CSS.new("p { color: blue }").render(:sass) #=> "p\n  color: blue"
+  #     Sass::CSS.new("p { color: blue }").render(:scss) #=> "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`).
-    # @option options :filename [String]
-    #     The filename of the CSS file being processed.
-    #     Used for error reporting
+    #     This is only meaningful when generating Sass code,
+    #     rather than SCSS.
     def initialize(template, options = {})
       if template.is_a? IO
         template = template.read
       end
 
-      @line = 1
       @options = options.dup
       # Backwards compatibility
       @options[:old] = true if @options[:alternate] == false
-      @template_str = template
+      @template = template
     end
 
-    # Converts the CSS template into Sass code.
+    # Converts the CSS template into Sass or SCSS code.
     #
-    # @return [String] The resulting Sass code
+    # @param fmt [Symbol] `:sass` or `:scss`, designating the format to return.
+    # @return [String] The resulting Sass or SCSS code
     # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
-    def render
-      @template = StringScanner.new(
-        Haml::Util.check_encoding(@template_str) do |msg, line|
-          raise Sass::SyntaxError.new(msg, :line => line)
-        end)
-      build_tree.to_sass(0, @options).strip + "\n"
+    def render(fmt = :sass)
+      Haml::Util.check_encoding(@template) do |msg, line|
+        raise Sass::SyntaxError.new(msg, :line => line)
+      end
+
+      build_tree.send("to_#{fmt}", @options).strip + "\n"
     rescue Sass::SyntaxError => err
-      err.modify_backtrace(:filename => @options[:filename] || '(css)', :line => @line)
+      err.modify_backtrace(:filename => @options[:filename] || '(css)')
       raise err
     end
 
@@ -100,9 +53,7 @@ module Sass
     #
     # @return [Tree::Node] The root node of the parsed tree
     def build_tree
-      root = Tree::RootNode.new(@template.string)
-      whitespace
-      rules              root
+      root = Sass::SCSS::CssParser.new(@template).parse
       expand_commas      root
       parent_ref_rules   root
       remove_parent_refs root
@@ -111,133 +62,6 @@ module Sass
       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 = 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 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 scan(/[^:\}\s]+/)
-        name = @template[0]
-        whitespace
-
-        assert_match /:/
-
-        value = ''
-        while 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 = scan(/\s*/) || ''
-
-      # If we've hit a comment,
-      # go past it and look for more whitespace
-      if scan(/\/\*/)
-        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 scan(re)
-        whitespace
-        return
-      end
-
-      pos = @template.pos
-
-      after = @template.string[[pos - 15, 0].max...pos].gsub(/.*\n/m, '')
-      after = "..." + after if pos >= 15
-
-      # Display basic regexps as plain old strings
-      string = re.source.gsub(/\\(.)/, '\1')
-      expected = re.source == Regexp.escape(string) ? string.inspect : re.inspect
-
-      was = @template.rest[0...15].gsub(/\n.*/m, '')
-      was += "..." if @template.rest.size >= 15
-      raise Sass::SyntaxError.new(
-        "Invalid CSS after #{after.inspect}: expected #{expected}, was #{was.inspect}")
-    end
-
-    # Identical to `@template.scan`, except that it increments the line count.
-    # `@template.scan` should never be called directly;
-    # this should be used instead.
-    def scan(re)
-      str = @template.scan(re)
-      @line += str.count "\n" if str
-      str
-    end
-
-    # Identical to `@template.scan_until`, except that it increments the line count.
-    # `@template.scan_until` should never be called directly;
-    # this should be used instead.
-    def scan_until(re)
-      str = @template.scan_until(re)
-      @line += str.count "\n" if str
-      str
-    end
-
     # Transform
     #
     #     foo, bar, baz
@@ -255,9 +79,9 @@ module Sass
     # @param root [Tree::Node] The parent node
     def expand_commas(root)
       root.children.map! do |child|
-        next child unless Tree::RuleNode === child && child.rules.first.include?(',')
-        child.rules.first.split(',').map do |rule|
-          node = Tree::RuleNode.new(rule.strip)
+        next child unless Tree::RuleNode === child && child.rule.first.include?(',')
+        child.rule.first.split(',').map do |rule|
+          node = Tree::RuleNode.new([rule.strip])
           node.children = child.children
           node
         end
@@ -301,22 +125,26 @@ module Sass
     # @param root [Tree::Node] The parent node
     def parent_ref_rules(root)
       current_rule = nil
-      root.children.select { |c| Tree::RuleNode === c }.each do |child|
-        root.children.delete child
-        first, rest = child.rules.first.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first
+      root.children.map! do |child|
+        next child unless child.is_a?(Tree::RuleNode)
+
+        first, rest = child.rule.first.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first
 
-        if current_rule.nil? || current_rule.rules.first != first
-          current_rule = Tree::RuleNode.new(first)
-          root << current_rule
+        if current_rule.nil? || current_rule.rule.first != first
+          current_rule = Tree::RuleNode.new([first])
         end
 
         if rest
-          child.rules = ["&" + rest]
+          child.rule = ["&" + rest]
           current_rule << child
         else
           current_rule.children += child.children
         end
+
+        current_rule
       end
+      root.children.compact!
+      root.children.uniq!
 
       root.children.each { |v| parent_ref_rules(v) }
     end
@@ -337,7 +165,7 @@ module Sass
     def remove_parent_refs(root)
       root.children.each do |child|
         if child.is_a?(Tree::RuleNode)
-          child.rules.first.gsub! /^& +/, ''
+          child.rule.first.gsub! /^& +/, ''
           remove_parent_refs child
         end
       end
@@ -378,10 +206,10 @@ module Sass
       while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
         child = rule.children.first
 
-        if child.rules.first[0] == ?&
-          rule.rules = [child.rules.first.gsub(/^&/, rule.rules.first)]
+        if child.rule.first[0] == ?&
+          rule.rule = [child.rule.first.gsub(/^&/, rule.rule.first)]
         else
-          rule.rules = ["#{rule.rules.first} #{child.rules.first}"]
+          rule.rule = ["#{rule.rule.first} #{child.rule.first}"]
         end
 
         rule.children = child.children
@@ -411,7 +239,7 @@ module Sass
         next child unless child.is_a?(Tree::RuleNode)
 
         if prev_rule && prev_rule.children == child.children
-          prev_rule.rules.first << ", #{child.rules.first}"
+          prev_rule.rule.first << ", #{child.rule.first}"
           next nil
         end
 

data/lib/sass/engine.rb

@@ -16,6 +16,7 @@ require 'sass/tree/debug_node'
 require 'sass/tree/import_node'
 require 'sass/environment'
 require 'sass/script'
+require 'sass/scss'
 require 'sass/error'
 require 'sass/files'
 require 'haml/shared'
@@ -123,7 +124,7 @@ module Sass
     # The regex that matches and extracts data from
     # properties of the form `name: prop`.
     # @private
-    PROPERTY_NEW = /^([^\s=:"]+)(\s*=|:)(?:\s+|$)(.*)/
+    PROPERTY_NEW = /^([^\s=:"]+)\s*(=|:)(?:\s+|$)(.*)/
 
     # The regex that matches and extracts data from
     # properties of the form `:name prop`.
@@ -136,6 +137,7 @@ module Sass
       :load_paths => ['.'],
       :cache => true,
       :cache_location => './.sass-cache',
+      :syntax => :sass,
     }.freeze
 
     # @param template [String] The Sass template.
@@ -174,8 +176,13 @@ module Sass
     def to_tree
       @template = check_encoding(@template) {|msg, line| raise Sass::SyntaxError.new(msg, :line => line)}
 
-      root = Tree::RootNode.new(@template)
-      append_children(root, tree(tabulate(@template)).first, true)
+      if @options[:syntax] == :scss
+        root = Sass::SCSS::Parser.new(@template).parse
+      else
+        root = Tree::RootNode.new(@template)
+        append_children(root, tree(tabulate(@template)).first, true)
+      end
+
       root.options = @options
       root
     rescue SyntaxError => e
@@ -286,11 +293,7 @@ MSG
         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
+        append_children(node, line.children, false)
       end
 
       node_or_nodes
@@ -298,6 +301,7 @@ MSG
 
     def append_children(parent, children, root)
       continued_rule = nil
+      continued_comment = nil
       children.each do |line|
         child = build_tree(parent, line, root)
 
@@ -320,6 +324,17 @@ MSG
           continued_rule, child = nil, continued_rule
         end
 
+        if child.is_a?(Tree::CommentNode) && child.silent
+          if continued_comment &&
+              child.line == continued_comment.line +
+              continued_comment.value.count("\n") + 1
+            continued_comment.value << "\n" << child.value
+            next
+          end
+
+          continued_comment = child
+        end
+
         check_for_no_children(child)
         validate_and_append_child(parent, child, line, root)
       end
@@ -331,17 +346,6 @@ MSG
     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 => line.index)
-        when Tree::ImportNode
-          raise SyntaxError.new("Import directives may only be used at the root of a document.",
-            :line => line.index)
-        end
-      end
-
       case child
       when Array
         child.each {|c| validate_and_append_child(parent, c, line, root)}
@@ -352,18 +356,10 @@ MSG
 
     def check_for_no_children(node)
       return unless node.is_a?(Tree::RuleNode) && node.children.empty?
-      warning = (node.rules.size == 1) ? <<SHORT : <<LONG
+      Haml::Util.haml_warn(<<WARNING.strip)
 WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
-Selector #{node.rules.first.inspect} doesn't have any properties and will not be rendered.
-SHORT
-
-WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
-Selector
-  #{node.rules.join("\n  ")}
-doesn't have any properties and will not be rendered.
-LONG
-
-      warn(warning.strip)
+This selector doesn't have any properties and will not be rendered.
+WARNING
     end
 
     def parse_line(parent, line, root)
@@ -376,23 +372,23 @@ LONG
           # which begin with ::,
           # as well as pseudo-classes
           # if we're using the new property syntax
-          Tree::RuleNode.new(line.text)
+          Tree::RuleNode.new(parse_interp(line.text))
         else
           parse_property(line, PROPERTY_OLD)
         end
-      when Script::VARIABLE_CHAR
+      when ?!, ?$
         parse_variable(line)
       when COMMENT_CHAR
         parse_comment(line.text)
       when DIRECTIVE_CHAR
         parse_directive(parent, line, root)
       when ESCAPE_CHAR
-        Tree::RuleNode.new(line.text[1..-1])
+        Tree::RuleNode.new(parse_interp(line.text[1..-1]))
       when MIXIN_DEFINITION_CHAR
         parse_mixin_definition(line)
       when MIXIN_INCLUDE_CHAR
         if line.text[1].nil? || line.text[1] == ?\s
-          Tree::RuleNode.new(line.text)
+          Tree::RuleNode.new(parse_interp(line.text))
         else
           parse_mixin_include(line, root)
         end
@@ -400,7 +396,7 @@ LONG
         if line.text =~ PROPERTY_NEW_MATCHER
           parse_property(line, PROPERTY_NEW)
         else
-          Tree::RuleNode.new(line.text)
+          Tree::RuleNode.new(parse_interp(line.text))
         end
       end
     end
@@ -411,29 +407,51 @@ LONG
       raise SyntaxError.new("Invalid property: \"#{line.text}\".",
         :line => @line) if name.nil? || value.nil?
 
-      expr = if (eq.strip[0] == SCRIPT_CHAR)
-        parse_script(value, :offset => line.offset + line.text.index(value))
+      if value.strip.empty?
+        expr = Sass::Script::String.new("")
       else
-        value
+        expr = parse_script(value, :offset => line.offset + line.text.index(value))
+
+        if eq.strip[0] == SCRIPT_CHAR
+          expr.context = :equals
+          Script.equals_warning("properties", name,
+            Sass::Tree::PropNode.val_to_sass(expr), false,
+            @line, line.offset + 1, @options[:filename])
+        end
       end
-      Tree::PropNode.new(name, expr, property_regx == PROPERTY_OLD ? :old : :new)
+      Tree::PropNode.new(
+        parse_interp(name), expr,
+        property_regx == PROPERTY_OLD ? :old : :new)
     end
 
     def parse_variable(line)
-      name, op, value = line.text.scan(Script::MATCH)[0]
+      name, op, value, default = line.text.scan(Script::MATCH)[0]
+      guarded = op =~ /^\|\|/
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath variable declarations.",
         :line => @line + 1) unless line.children.empty?
       raise SyntaxError.new("Invalid variable: \"#{line.text}\".",
         :line => @line) unless name && value
+      Script.var_warning(name, @line, line.offset + 1, @options[:filename]) if line.text[0] == ?!
+
+      expr = parse_script(value, :offset => line.offset + line.text.index(value))
+      if op =~ /=$/
+        expr.context = :equals
+        type = guarded ? "variable defaults" : "variables"
+        Script.equals_warning(type, "$#{name}", expr.to_sass,
+          guarded, @line, line.offset + 1, @options[:filename])
+      end
 
-      Tree::VariableNode.new(name, parse_script(value, :offset => line.offset + line.text.index(value)), op == '||=')
+      Tree::VariableNode.new(name, expr, default || guarded)
     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)
+        silent = line[1] == SASS_COMMENT_CHAR
+        Tree::CommentNode.new(
+          format_comment_text(line[2..-1], silent),
+          silent)
       else
-        Tree::RuleNode.new(line)
+        Tree::RuleNode.new(parse_interp(line))
       end
     end
 
@@ -447,6 +465,10 @@ LONG
         raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.",
           :line => @line + 1) unless line.children.empty?
         value.split(/,\s*/).map {|f| Tree::ImportNode.new(f)}
+      elsif directive == "mixin"
+        parse_mixin_definition(line)
+      elsif directive == "include"
+        parse_mixin_include(line, root)
       elsif directive == "for"
         parse_for(line, root, value)
       elsif directive == "else"
@@ -482,14 +504,18 @@ LONG
         raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.")
       end
       raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
+      if var.slice!(0) == ?!
+        offset = line.offset + line.text.index("!" + var) + 1
+        Script.var_warning(var, @line, offset, @options[:filename])
+      end
 
       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')
+      Tree::ForNode.new(var, parsed_from, parsed_to, to_name == 'to')
     end
 
     def parse_else(parent, line, text)
-      previous = parent.last
+      previous = parent.children.last
       raise SyntaxError.new("@else must come after @if.") unless previous.is_a?(Tree::IfNode)
 
       if text
@@ -505,8 +531,10 @@ LONG
       nil
     end
 
+    # @private
+    MIXIN_DEF_RE = /^(?:=|@mixin)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_definition(line)
-      name, arg_string = line.text.scan(/^=\s*([^(]+)(.*)$/).first
+      name, arg_string = line.text.scan(MIXIN_DEF_RE).first
       raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
@@ -516,8 +544,10 @@ LONG
       Tree::MixinDefNode.new(name, args)
     end
 
+    # @private
+    MIXIN_INCLUDE_RE = /^(?:\+|@include)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_include(line, root)
-      name, arg_string = line.text.scan(/^\+\s*([^(]+)(.*)$/).first
+      name, arg_string = line.text.scan(MIXIN_INCLUDE_RE).first
       raise SyntaxError.new("Invalid mixin include \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
@@ -533,5 +563,49 @@ LONG
       offset = options[:offset] || 0
       Script.parse(script, line, offset, @options)
     end
+
+    def format_comment_text(text, silent)
+      content = text.split("\n")
+
+      if content.first && content.first.strip.empty?
+        removed_first = true
+        content.shift
+      end
+
+      return silent ? "//" : "/* */" if content.empty?
+      content.map! {|l| (l.empty? ? "" : " ") + l}
+      content.first.gsub!(/^ /, '') unless removed_first
+      content.last.gsub!(%r{ ?\*/ *$}, '')
+      if silent
+        "//" + content.join("\n//")
+      else
+        "/*" + content.join("\n *") + " */"
+      end
+    end
+
+    def parse_interp(text)
+      self.class.parse_interp(text, @line, :filename => @filename)
+    end
+
+    # It's important that this have strings (at least)
+    # at the beginning, the end, and between each Script::Node.
+    #
+    # @private
+    def self.parse_interp(text, line, options)
+      res = []
+      rest = Haml::Shared.handle_interpolation text do |scan|
+        escapes = scan[2].size
+        res << scan.matched[0...-2 - escapes]
+        if escapes % 2 == 1
+          res << "\\" * (escapes - 1) << '#{'
+        else
+          res << "\\" * [0, escapes - 1].max
+          res << Script::Parser.new(
+            scan, line, scan.pos - scan.matched_size, options).
+            parse_interpolated
+        end
+      end
+      res << rest
+    end
   end
 end