haml_ejs 0.0.1

data/vendor/sass/lib/sass/tree/visitors/convert.rb

@@ -0,0 +1,255 @@
+# A visitor for converting a Sass tree into a source string.
+class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
+  # Runs the visitor on a tree.
+  #
+  # @param root [Tree::Node] The root node of the Sass tree.
+  # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+  # @param format [Symbol] `:sass` or `:scss`.
+  # @return [String] The Sass or SCSS source for the tree.
+  def self.visit(root, options, format)
+    new(options, format).send(:visit, root)
+  end
+
+  protected
+
+  def initialize(options, format)
+    @options = options
+    @format = format
+    @tabs = 0
+  end
+
+  def visit_children(parent)
+    @tabs += 1
+    return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
+    (@format == :sass ? "\n" : " {\n") + super.join.rstrip + (@format == :sass ? "\n" : " }\n")
+  ensure
+    @tabs -= 1
+  end
+
+  # Ensures proper spacing between top-level nodes.
+  def visit_root(node)
+    Sass::Util.enum_cons(node.children + [nil], 2).map do |child, nxt|
+      visit(child) +
+        if nxt &&
+            (child.is_a?(Sass::Tree::CommentNode) &&
+              child.line + child.value.count("\n") + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::ImportNode) && nxt.is_a?(Sass::Tree::ImportNode) &&
+              child.line + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::VariableNode) && nxt.is_a?(Sass::Tree::VariableNode) &&
+              child.line + 1 == nxt.line)
+          ""
+        else
+          "\n"
+        end
+    end.join.rstrip + "\n"
+  end
+
+  def visit_charset(node)
+    "#{tab_str}@charset \"#{node.name}\"#{semi}\n"
+  end
+
+  def visit_comment(node)
+    content = if @format == :sass
+      content = node.value.gsub(/\*\/$/, '').rstrip
+      if content =~ /\A[ \t]/
+        # Re-indent SCSS comments like this:
+        #     /* foo
+        #   bar
+        #       baz */
+        content.gsub!(/^/, '   ')
+        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
+      end
+
+      content =
+        unless content.include?("\n")
+          content
+        else
+          content.gsub!(/\n( \*|\/\/)/, "\n  ")
+          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
+          sep = node.silent ? "\n//" : "\n *"
+          if spaces >= 2
+            content.gsub(/\n  /, sep)
+          else
+            content.gsub(/\n#{' ' * spaces}/, sep)
+          end
+        end
+
+      content.gsub!(/\A\/\*/, '//') if node.silent
+      content.gsub!(/^/, tab_str)
+      content.rstrip + "\n"
+    else
+      spaces = ('  ' * [@tabs - node.value[/^ */].size, 0].max)
+      content = if node.silent
+        node.value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
+      else
+        node.value
+      end.gsub(/^/, spaces) + "\n"
+      content
+    end
+    if node.loud
+      if node.silent
+        content.gsub!(%r{^\s*(//!?)}, '//!')
+      else
+        content.sub!(%r{^\s*(/\*)}, '/*!')
+      end
+    end
+    content
+  end
+
+  def visit_debug(node)
+    "#{tab_str}@debug #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
+  def visit_directive(node)
+    res = "#{tab_str}#{node.value}"
+    return res + "#{semi}\n" unless node.has_children
+    res + yield + "\n"
+  end
+
+  def visit_each(node)
+    "#{tab_str}@each $#{dasherize(node.var)} in #{node.list.to_sass(@options)}#{yield}"
+  end
+
+  def visit_extend(node)
+    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}\n"
+  end
+
+  def visit_for(node)
+    "#{tab_str}@for $#{dasherize(node.var)} from #{node.from.to_sass(@options)} " +
+      "#{node.exclusive ? "to" : "through"} #{node.to.to_sass(@options)}#{yield}"
+  end
+
+  def visit_function(node)
+    args = node.args.map do |v, d|
+      d ? "#{v.to_sass(@options)}: #{d.to_sass(@options)}" : v.to_sass(@options)
+    end.join(", ")
+
+    "#{tab_str}@function #{dasherize(node.name)}(#{args})#{yield}"
+  end
+
+  def visit_if(node)
+    name =
+      if !@is_else; "if"
+      elsif node.expr; "else if"
+      else; "else"
+      end
+    str = "#{tab_str}@#{name}"
+    str << " #{node.expr.to_sass(@options)}" if node.expr
+    str << yield
+    @is_else = true
+    str << visit(node.else) if node.else
+    str
+  ensure
+    @is_else = false
+  end
+
+  def visit_import(node)
+    quote = @format == :scss ? '"' : ''
+    "#{tab_str}@import #{quote}#{node.imported_filename}#{quote}#{semi}\n"
+  end
+
+  def visit_media(node)
+    "#{tab_str}@media #{node.query}#{yield}"
+  end
+
+  def visit_mixindef(node)
+    args =
+      if node.args.empty?
+        ""
+      else
+        '(' + node.args.map do |v, d|
+          if d
+            "#{v.to_sass(@options)}: #{d.to_sass(@options)}"
+          else
+            v.to_sass(@options)
+          end
+        end.join(", ") + ')'
+      end
+          
+    "#{tab_str}#{@format == :sass ? '=' : '@mixin '}#{dasherize(node.name)}#{args}#{yield}"
+  end
+
+  def visit_mixin(node)
+    unless node.args.empty? && node.keywords.empty?
+      args = node.args.map {|a| a.to_sass(@options)}.join(", ")
+      keywords = node.keywords.map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
+      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
+    end
+    "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{semi}\n"
+  end
+
+  def visit_prop(node)
+    res = tab_str + node.declaration(@options, @format)
+    return res + semi + "\n" if node.children.empty?
+    res + yield.rstrip + semi + "\n"
+  end
+
+  def visit_return(node)
+    "#{tab_str}@return #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
+  def visit_rule(node)
+    if @format == :sass
+      name = selector_to_sass(node.rule)
+      name = "\\" + name if name[0] == ?:
+      name.gsub(/^/, tab_str) + yield
+    elsif @format == :scss
+      name = selector_to_scss(node.rule)
+      res = name + yield
+      if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.silent
+        res.slice!(-3..-1)
+        res << "\n" << tab_str << "}\n"
+      end
+      res
+    end
+  end
+
+  def visit_variable(node)
+    "#{tab_str}$#{dasherize(node.name)}: #{node.expr.to_sass(@options)}#{' !default' if node.guarded}#{semi}\n"
+  end
+
+  def visit_warn(node)
+    "#{tab_str}@warn #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
+  def visit_while(node)
+    "#{tab_str}@while #{node.expr.to_sass(@options)}#{yield}"
+  end
+
+  private
+
+  def selector_to_src(sel)
+    @format == :sass ? selector_to_sass(sel) : selector_to_scss(sel)
+  end
+
+  def selector_to_sass(sel)
+    sel.map do |r|
+      if r.is_a?(String)
+        r.gsub(/(,[ \t]*)?\n\s*/) {$1 ? $1 + "\n" : " "}
+      else
+        "\#{#{r.to_sass(@options)}}"
+      end
+    end.join
+  end
+
+  def selector_to_scss(sel)
+    sel.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(@options)}}"}.
+      join.gsub(/^[ \t]*/, tab_str)
+  end
+
+  def semi
+    @format == :sass ? "" : ";"
+  end
+
+  def tab_str
+    '  ' * @tabs
+  end
+
+  def dasherize(s)
+    if @options[:dasherize]
+      s.gsub('_', '-')
+    else
+      s
+    end
+  end
+end

data/vendor/sass/lib/sass/tree/visitors/cssize.rb

@@ -0,0 +1,175 @@
+# A visitor for converting a static Sass tree into a static CSS tree.
+class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
+  # @param root [Tree::Node] The root node of the tree to visit.
+  # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
+  #   *and* the extensions defined for this tree
+  def self.visit(root); super; end
+
+  protected
+
+  # Returns the immediate parent of the current node.
+  # @return [Tree::Node]
+  attr_reader :parent
+
+  def initialize
+    @extends = Sass::Util::SubsetMap.new
+  end
+
+  # If an exception is raised, this adds proper metadata to the backtrace.
+  def visit(node)
+    super(node.dup)
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Keeps track of the current parent node.
+  def visit_children(parent)
+    with_parent parent do
+      parent.children = super.flatten
+      parent
+    end
+  end
+
+  # Runs a block of code with the current parent node
+  # replaced with the given node.
+  #
+  # @param parent [Tree::Node] The new parent for the duration of the block.
+  # @yield A block in which the parent is set to `parent`.
+  # @return [Object] The return value of the block.
+  def with_parent(parent)
+    old_parent, @parent = @parent, parent
+    yield
+  ensure
+    @parent = old_parent
+  end
+
+  # In Ruby 1.8, ensures that there's only one `@charset` directive
+  # and that it's at the top of the document.
+  #
+  # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
+  #   *and* the extensions defined for this tree
+  def visit_root(node)
+    yield
+
+    # In Ruby 1.9 we can make all @charset nodes invisible
+    # and infer the final @charset from the encoding of the final string.
+    if Sass::Util.ruby1_8? && parent.nil?
+      charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
+      node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
+      node.children.unshift charset if charset
+    end
+
+    return node, @extends
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  # Registers an extension in the `@extends` subset map.
+  def visit_extend(node)
+    node.resolved_selector.members.each do |seq|
+      if seq.members.size > 1
+        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
+      end
+
+      sseq = seq.members.first
+      if !sseq.is_a?(Sass::Selector::SimpleSequence)
+        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
+      end
+
+      sel = sseq.members
+      parent.resolved_rules.members.each do |seq|
+        if !seq.members.last.is_a?(Sass::Selector::SimpleSequence)
+          raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
+        end
+
+        @extends[sel] = seq
+      end
+    end
+
+    []
+  end
+
+  # Modifies exception backtraces to include the imported file.
+  def visit_import(node)
+    # Don't use #visit_children to avoid adding the import node to the list of parents.
+    node.children.map {|c| visit(c)}.flatten
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.children.first.filename)
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Bubbles the `@media` directive up through RuleNodes
+  # and merges it with other `@media` directives.
+  def visit_media(node)
+    if parent.is_a?(Sass::Tree::RuleNode)
+      new_rule = parent.dup
+      new_rule.children = node.children
+      node.children = with_parent(node) {Array(visit(new_rule))}
+      # If the last child is actually the end of the group,
+      # the parent's cssize will set it properly
+      node.children.last.group_end = false unless node.children.empty?
+    else
+      yield
+    end
+
+    media = node.children.select {|c| c.is_a?(Sass::Tree::MediaNode)}
+    node.children.reject! {|c| c.is_a?(Sass::Tree::MediaNode)}
+    media.each {|n| n.query = "#{node.query} and #{n.query}"}
+    (node.children.empty? ? [] : [node]) + media
+  end
+
+  # Asserts that all the mixin's children are valid in their new location.
+  def visit_mixin(node)
+    # Don't use #visit_children to avoid adding the mixin node to the list of parents.
+    node.children.map {|c| visit(c)}.flatten
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:mixin => node.name, :filename => node.filename, :line => node.line)
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Converts nested properties into flat properties
+  # and updates the indentation of the prop node based on the nesting level.
+  def visit_prop(node)
+    if parent.is_a?(Sass::Tree::PropNode)
+      node.resolved_name = "#{parent.resolved_name}-#{node.resolved_name}"
+      node.tabs = parent.tabs + (parent.resolved_value.empty? ? 0 : 1) if node.style == :nested
+    end
+
+    yield
+
+    result = node.children.dup
+    if !node.resolved_value.empty? || node.children.empty?
+      node.send(:check!)
+      result.unshift(node)
+    end
+
+    result
+  end
+
+  # Resolves parent references and nested selectors,
+  # and updates the indentation of the rule node based on the nesting level.
+  def visit_rule(node)
+    parent_resolved_rules = parent.is_a?(Sass::Tree::RuleNode) ? parent.resolved_rules : nil
+    # It's possible for resolved_rules to be set if we've duplicated this node during @media bubbling
+    node.resolved_rules ||= node.parsed_rules.resolve_parent_refs(parent_resolved_rules)
+
+    yield
+
+    rules = node.children.select {|c| c.is_a?(Sass::Tree::RuleNode) || c.is_a?(Sass::Tree::MediaNode)}
+    props = node.children.reject {|c| c.is_a?(Sass::Tree::RuleNode) || c.is_a?(Sass::Tree::MediaNode) || c.invisible?}
+
+    unless props.empty?
+      node.children = props
+      rules.each {|r| r.tabs += 1} if node.style == :nested
+      rules.unshift(node)
+    end
+
+    rules.last.group_end = true unless parent.is_a?(Sass::Tree::RuleNode) || rules.empty?
+
+    rules
+  end
+end

data/vendor/sass/lib/sass/tree/visitors/perform.rb

@@ -0,0 +1,301 @@
+# A visitor for converting a dynamic Sass tree into a static Sass tree.
+class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+  # @param root [Tree::Node] The root node of the tree to visit.
+  # @param environment [Sass::Environment] The lexical environment.
+  # @return [Tree::Node] The resulting tree of static nodes.
+  def self.visit(root, environment = Sass::Environment.new)
+    new(environment).send(:visit, root)
+  end
+
+  protected
+
+  def initialize(env)
+    @environment = env
+  end
+
+  # If an exception is raised, this add proper metadata to the backtrace.
+  def visit(node)
+    super(node.dup)
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Keeps track of the current environment.
+  def visit_children(parent)
+    with_environment Sass::Environment.new(@environment) do
+      parent.children = super.flatten
+      parent
+    end
+  end
+
+  # Runs a block of code with the current environment replaced with the given one.
+  #
+  # @param env [Sass::Environment] The new environment for the duration of the block.
+  # @yield A block in which the environment is set to `env`.
+  # @return [Object] The return value of the block.
+  def with_environment(env)
+    old_env, @environment = @environment, env
+    yield
+  ensure
+    @environment = old_env
+  end
+
+  # Sets the options on the environment if this is the top-level root.
+  def visit_root(node)
+    @environment.options = node.options if @environment.options.nil? || @environment.options.empty?
+    yield
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  # Removes this node from the tree if it's a silent comment.
+  def visit_comment(node)
+    return [] if node.invisible?
+    if node.evaluated?
+      node.value.gsub!(/(^|[^\\])\#\{([^}]*)\}/) do |md|
+        $1+Sass::Script.parse($2, node.line, 0, node.options).perform(@environment).to_s
+      end
+      node.value = run_interp([Sass::Script::String.new(node.value)])
+    end
+    node
+  end
+
+  # Prints the expression to STDERR.
+  def visit_debug(node)
+    res = node.expr.perform(@environment)
+    res = res.value if res.is_a?(Sass::Script::String)
+    if node.filename
+      $stderr.puts "#{node.filename}:#{node.line} DEBUG: #{res}"
+    else
+      $stderr.puts "Line #{node.line} DEBUG: #{res}"
+    end
+    []
+  end
+
+  # Runs the child nodes once for each value in the list.
+  def visit_each(node)
+    list = node.list.perform(@environment)
+
+    with_environment Sass::Environment.new(@environment) do
+      list.to_a.map do |v|
+        @environment.set_local_var(node.var, v)
+        node.children.map {|c| visit(c)}
+      end.flatten
+    end
+  end
+
+  # Runs SassScript interpolation in the selector,
+  # and then parses the result into a {Sass::Selector::CommaSequence}.
+  def visit_extend(node)
+    parser = Sass::SCSS::CssParser.new(run_interp(node.selector), node.line)
+    node.resolved_selector = parser.parse_selector(node.filename)
+    node
+  end
+
+  # Runs the child nodes once for each time through the loop, varying the variable each time.
+  def visit_for(node)
+    from = node.from.perform(@environment)
+    to = node.to.perform(@environment)
+    from.assert_int!
+    to.assert_int!
+
+    to = to.coerce(from.numerator_units, from.denominator_units)
+    range = Range.new(from.to_i, to.to_i, node.exclusive)
+
+    with_environment Sass::Environment.new(@environment) do
+      range.map do |i|
+        @environment.set_local_var(node.var,
+          Sass::Script::Number.new(i, from.numerator_units, from.denominator_units))
+        node.children.map {|c| visit(c)}
+      end.flatten
+    end
+  end
+
+  # Loads the function into the environment.
+  def visit_function(node)
+    @environment.set_function(node.name,
+      Sass::Callable.new(node.name, node.args, @environment, node.children))
+    []
+  end
+
+  # Runs the child nodes if the conditional expression is true;
+  # otherwise, tries the else nodes.
+  def visit_if(node)
+    if node.expr.nil? || node.expr.perform(@environment).to_bool
+      yield
+      node.children
+    elsif node.else
+      visit(node.else)
+    else
+      []
+    end
+  end
+
+  # Returns a static DirectiveNode if this is importing a CSS file,
+  # or parses and includes the imported Sass file.
+  def visit_import(node)
+    if path = node.css_import?
+      return Sass::Tree::DirectiveNode.new("@import url(#{path})")
+    end
+
+    @environment.push_frame(:filename => node.filename, :line => node.line)
+    root = node.imported_file.to_tree
+    node.children = root.children.map {|c| visit(c)}.flatten
+    node
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.imported_file.options[:filename])
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  ensure
+    @environment.pop_frame
+  end
+
+  # Loads a mixin into the environment.
+  def visit_mixindef(node)
+    @environment.set_mixin(node.name,
+      Sass::Callable.new(node.name, node.args, @environment, node.children))
+    []
+  end
+
+  # Runs a mixin.
+  def visit_mixin(node)
+    handle_include_loop!(node) if @environment.mixins_in_use.include?(node.name)
+
+    original_env = @environment
+    original_env.push_frame(:filename => node.filename, :line => node.line)
+    original_env.prepare_frame(:mixin => node.name)
+    raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin = @environment.mixin(node.name)
+
+    passed_args = node.args.dup
+    passed_keywords = node.keywords.dup
+
+    raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < passed_args.size
+Mixin #{node.name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
+ but #{node.args.size} #{node.args.size == 1 ? 'was' : 'were'} passed.
+END
+
+    passed_keywords.each do |name, value|
+      # TODO: Make this fast
+      unless mixin.args.find {|(var, default)| var.underscored_name == name}
+        raise Sass::SyntaxError.new("Mixin #{node.name} doesn't have an argument named $#{name}")
+      end
+    end
+
+    environment = mixin.args.zip(passed_args).
+      inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
+      env.set_local_var(var.name,
+        if value
+          value.perform(@environment)
+        elsif kv = passed_keywords[var.underscored_name]
+          kv.perform(@environment)
+        elsif default
+          default.perform(env)
+        end)
+      raise Sass::SyntaxError.new("Mixin #{node.name} is missing parameter #{var.inspect}.") unless env.var(var.name)
+      env
+    end
+
+    with_environment(environment) {node.children = mixin.tree.map {|c| visit(c)}.flatten}
+    node
+  rescue Sass::SyntaxError => e
+    if original_env # Don't add backtrace info if this is an @include loop
+      e.modify_backtrace(:mixin => node.name, :line => node.line)
+      e.add_backtrace(:line => node.line)
+    end
+    raise e
+  ensure
+    original_env.pop_frame if original_env
+  end
+
+  # Runs any SassScript that may be embedded in a property.
+  def visit_prop(node)
+    node.resolved_name = run_interp(node.name)
+    val = node.value.perform(@environment)
+    node.resolved_value = val.to_s
+    yield
+  end
+
+  # Returns the value of the expression.
+  def visit_return(node)
+    throw :_sass_return, node.expr.perform(@environment)
+  end
+
+  # Runs SassScript interpolation in the selector,
+  # and then parses the result into a {Sass::Selector::CommaSequence}.
+  def visit_rule(node)
+    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.line)
+    node.parsed_rules ||= parser.parse_selector(node.filename)
+    yield
+  end
+
+  # Loads the new variable value into the environment.
+  def visit_variable(node)
+    return [] if node.guarded && !@environment.var(node.name).nil?
+    val = node.expr.perform(@environment)
+    @environment.set_var(node.name, val)
+    []
+  end
+
+  # Prints the expression to STDERR with a stylesheet trace.
+  def visit_warn(node)
+    @environment.push_frame(:filename => node.filename, :line => node.line)
+    res = node.expr.perform(@environment)
+    res = res.value if res.is_a?(Sass::Script::String)
+    msg = "WARNING: #{res}\n"
+    @environment.stack.reverse.each_with_index do |entry, i|
+      msg << "        #{i == 0 ? "on" : "from"} line #{entry[:line]}" <<
+        " of #{entry[:filename] || "an unknown file"}"
+      msg << ", in `#{entry[:mixin]}'" if entry[:mixin]
+      msg << "\n"
+    end
+    Sass::Util.sass_warn msg
+    []
+  ensure
+    @environment.pop_frame
+  end
+
+  # Runs the child nodes until the continuation expression becomes false.
+  def visit_while(node)
+    children = []
+    with_environment Sass::Environment.new(@environment) do
+      children += node.children.map {|c| visit(c)} while node.expr.perform(@environment).to_bool
+    end
+    children.flatten
+  end
+
+  def visit_directive(node)
+    if node.value['#{']
+      node.value = run_interp(Sass::Engine.parse_interp(node.value, node.line, 0, node.options))
+    end
+    yield
+    node
+  end
+
+  private
+
+  def run_interp(text)
+    text.map do |r|
+      next r if r.is_a?(String)
+      val = r.perform(@environment)
+      # Interpolated strings should never render with quotes
+      next val.value if val.is_a?(Sass::Script::String)
+      val.to_s
+    end.join.strip
+  end
+
+  def handle_include_loop!(node)
+    msg = "An @include loop has been found:"
+    mixins = @environment.stack.map {|s| s[:mixin]}.compact
+    if mixins.size == 2 && mixins[0] == mixins[1]
+      raise Sass::SyntaxError.new("#{msg} #{node.name} includes itself")
+    end
+
+    mixins << node.name
+    msg << "\n" << Sass::Util.enum_cons(mixins, 2).map do |m1, m2|
+      "    #{m1} includes #{m2}"
+    end.join("\n")
+    raise Sass::SyntaxError.new(msg)
+  end
+end