sass 3.1.21 → 3.2.0.alpha.3

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

@@ -12,13 +12,12 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   attr_reader :parent
 
   def initialize
-    @parent_directives = []
     @extends = Sass::Util::SubsetMap.new
   end
 
   # If an exception is raised, this adds proper metadata to the backtrace.
   def visit(node)
-    super(node)
+    super(node.dup)
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.filename, :line => node.line)
     raise e
@@ -39,11 +38,9 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # @yield A block in which the parent is set to `parent`.
   # @return [Object] The return value of the block.
   def with_parent(parent)
-    @parent_directives.push parent if parent.is_a?(Sass::Tree::DirectiveNode)
     old_parent, @parent = @parent, parent
     yield
   ensure
-    @parent_directives.pop if parent.is_a?(Sass::Tree::DirectiveNode)
     @parent = old_parent
   end
 
@@ -55,26 +52,12 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   def visit_root(node)
     yield
 
-    if parent.nil?
-      # 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?
-        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
-
-      imports = Sass::Util.extract!(node.children) do |c|
-        c.is_a?(Sass::Tree::DirectiveNode) && c.value =~ /^@import /i
-      end
-      charset_and_index = Sass::Util.ruby1_8? &&
-        node.children.each_with_index.find {|c, _| c.is_a?(Sass::Tree::CharsetNode)}
-      if charset_and_index
-        index = charset_and_index.last
-        node.children = node.children[0..index] + imports + node.children[index+1..-1]
-      else
-        node.children = imports + node.children
-      end
+    # 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
@@ -83,18 +66,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     raise e
   end
 
-  # A simple struct wrapping up information about a single `@extend` instance. A
-  # single [ExtendNode] can have multiple Extends if either the parent node or
-  # the extended selector is a comma sequence.
-  #
-  # @attr extender [Array<Sass::Selector::SimpleSequence, String>]
-  #   The selector of the CSS rule containing the `@extend`.
-  # @attr target [Array<Sass::Selector::Simple>] The selector being `@extend`ed.
-  # @attr node [Sass::Tree::ExtendNode] The node that produced this extend.
-  # @attr directives [Array<Sass::Tree::DirectiveNode>]
-  #   The directives containing the `@extend`.
-  Extend = Struct.new(:extender, :target, :node, :directives)
-
   # Registers an extension in the `@extends` subset map.
   def visit_extend(node)
     node.resolved_selector.members.each do |seq|
@@ -113,7 +84,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
           raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
         end
 
-        @extends[sel] = Extend.new(seq, sel, node, @parent_directives.dup)
+        @extends[sel] = seq
       end
     end
 
@@ -146,9 +117,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
     media = node.children.select {|c| c.is_a?(Sass::Tree::MediaNode)}
     node.children.reject! {|c| c.is_a?(Sass::Tree::MediaNode)}
-    media.each do |n|
-      n.query = node.query.map {|pq| n.query.map {|cq| "#{pq} and #{cq}"}}.flatten
-    end
+    media.each {|n| n.query = "#{node.query} and #{n.query}"}
     (node.children.empty? ? [] : [node]) + media
   end
 

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

@@ -53,10 +53,12 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Removes this node from the tree if it's a silent comment.
   def visit_comment(node)
     return [] if node.invisible?
-    check_for_loud_silent_comment node
-    check_for_comment_interp node
-    node.resolved_value = run_interp_no_strip(node.value)
-    node.resolved_value.gsub!(/\\([\\#])/, '\1')
+    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
 
@@ -87,8 +89,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # 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.filename, node.line)
-    node.resolved_selector = parser.parse_selector
+    parser = Sass::SCSS::CssParser.new(run_interp(node.selector), node.line)
+    node.resolved_selector = parser.parse_selector(node.filename)
     node
   end
 
@@ -137,12 +139,9 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     if path = node.css_import?
       return Sass::Tree::DirectiveNode.new("@import url(#{path})")
     end
-    file = node.imported_file
-    handle_import_loop!(node) if @environment.files_in_use.include?(file.options[:filename])
 
     @environment.push_frame(:filename => node.filename, :line => node.line)
-    root = file.to_tree
-    Sass::Tree::Visitors::CheckNesting.visit(root)
+    root = node.imported_file.to_tree
     node.children = root.children.map {|c| visit(c)}.flatten
     node
   rescue Sass::SyntaxError => e
@@ -226,15 +225,8 @@ END
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
-    rule = node.rule
-    rule = rule.map {|e| e.is_a?(String) && e != ' ' ? e.strip : e} if node.style == :compressed
-    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.filename, node.line)
-    node.parsed_rules ||= parser.parse_selector
-    if node.options[:trace_selectors]
-      @environment.push_frame(:filename => node.filename, :line => node.line)
-      node.stack_trace = @environment.stack_trace
-      @environment.pop_frame
-    end
+    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.line)
+    node.parsed_rules ||= parser.parse_selector(node.filename)
     yield
   end
 
@@ -251,10 +243,13 @@ END
     @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         "
-    msg << @environment.stack_trace.join("\n         ")
-    # JRuby doesn't automatically add a newline for #warn
-    msg << (RUBY_PLATFORM =~ /java/ ? "\n\n" : "\n")
+    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
@@ -272,15 +267,6 @@ END
 
   def visit_directive(node)
     if node.value['#{']
-      if node.value =~ /^@import (?!url\()/
-        Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
-@import directives using \#{} interpolation will need to use url() in Sass 3.2.
-For example:
-
-  @import url("http://\#{$url}/style.css");
-WARNING
-      end
       node.value = run_interp(Sass::Engine.parse_interp(node.value, node.line, 0, node.options))
     end
     yield
@@ -289,24 +275,22 @@ WARNING
 
   private
 
-  def run_interp_no_strip(text)
+  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
-  end
-
-  def run_interp(text)
-    run_interp_no_strip(text).strip
+    end.join.strip
   end
 
   def handle_include_loop!(node)
     msg = "An @include loop has been found:"
     mixins = @environment.stack.map {|s| s[:mixin]}.compact
-    raise Sass::SyntaxError.new("#{msg} #{node.name} includes itself") if mixins.size == 1
+    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|
@@ -314,44 +298,4 @@ WARNING
     end.join("\n")
     raise Sass::SyntaxError.new(msg)
   end
-
-  def handle_import_loop!(node)
-    msg = "An @import loop has been found:"
-    files = @environment.stack.map {|s| s[:filename]}.compact
-    if node.filename == node.imported_file.options[:filename]
-      raise Sass::SyntaxError.new("#{msg} #{node.filename} imports itself")
-    end
-
-    files << node.filename << node.imported_file.options[:filename]
-    msg << "\n" << Sass::Util.enum_cons(files, 2).map do |m1, m2|
-      "    #{m1} imports #{m2}"
-    end.join("\n")
-    raise Sass::SyntaxError.new(msg)
-  end
-
-  def check_for_loud_silent_comment(node)
-    return unless node.loud && node.silent
-    Sass::Util.sass_warn <<MESSAGE
-WARNING:
-On line #{node.line}#{" of '#{node.filename}'" if node.filename}
-`//` comments will no longer be allowed to use the `!` flag in Sass 3.2.
-Please change to `/*` comments.
-MESSAGE
-  end
-
-  def check_for_comment_interp(node)
-    return if node.loud
-    node.value.each do |e|
-      next unless e.is_a?(String)
-      e.scan(/(\\*)#\{/) do |esc|
-        Sass::Util.sass_warn <<MESSAGE if esc.first.size.even?
-WARNING:
-On line #{node.line}#{" of '#{node.filename}'" if node.filename}
-Comments will evaluate the contents of interpolations (\#{ ... }) in Sass 3.2.
-Please escape the interpolation by adding a backslash before the `#`.
-MESSAGE
-        return
-      end
-    end
-  end
 end

data/lib/sass/tree/visitors/to_css.rb

@@ -57,24 +57,32 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   def visit_comment(node)
     return if node.invisible?
-    spaces = ('  ' * [@tabs - node.resolved_value[/^ */].size, 0].max)
+    spaces = ('  ' * [@tabs - node.value[/^ */].size, 0].max)
 
-    content = node.resolved_value.gsub(/^/, spaces)
-    content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"} if node.silent
+    content = node.value.gsub(/^/, spaces).gsub(%r{^(\s*)//(.*)$}) do |md|
+      "#{$1}/*#{$2} */"
+    end
+    if content =~ /[^\\]\#\{.*\}/
+      Sass::Util.sass_warn <<MESSAGE
+WARNING:
+On line #{node.line}#{" of '#{node.filename}'" if node.filename}
+Comments will evaluate the contents of interpolations (\#{ ... }) in Sass 3.2.
+Please escape the interpolation by adding a backslash before the hash sign.
+MESSAGE
+    elsif content =~ /\\\#\{.*\}/
+      content.gsub!(/\\(\#\{.*\})/, '\1')
+    end
     content.gsub!(/\n +(\* *(?!\/))?/, ' ') if (node.style == :compact || node.style == :compressed) && !node.loud
     content
   end
 
   def visit_directive(node)
-    was_in_directive = @in_directive
-    tab_str = '  ' * @tabs
-    return tab_str + node.value + ";" unless node.has_children
-    return tab_str + node.value + " {}" if node.children.empty?
-    @in_directive = @in_directive || !node.is_a?(Sass::Tree::MediaNode)
+    return node.value + ";" unless node.has_children
+    return node.value + " {}" if node.children.empty?
     result = if node.style == :compressed
                "#{node.value}{"
              else
-               "#{tab_str}#{node.value} {" + (node.style == :compact ? ' ' : "\n")
+               "#{'  ' * @tabs}#{node.value} {" + (node.style == :compact ? ' ' : "\n")
              end
     was_prop = false
     first = true
@@ -103,8 +111,6 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
                     else
                       (node.style == :expanded ? "\n" : " ") + "}\n"
                     end
-  ensure
-    @in_directive = was_in_directive
   end
 
   def visit_media(node)
@@ -136,11 +142,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
       joined_rules = node.resolved_rules.members.map do |seq|
         rule_part = seq.to_a.join
-        if node.style == :compressed
-          rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
-          rule_part.gsub!(/\s*([,+>])\s*/m, '\1')
-          rule_part.strip!
-        end
+        rule_part.gsub!(/\s*([^,])\s*\n\s*/m, '\1 ') if node.style == :compressed
         rule_part
       end.join(rule_separator)
 
@@ -152,12 +154,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       old_spaces = '  ' * @tabs
       spaces = '  ' * (@tabs + 1)
       if node.style != :compressed
-        if node.options[:debug_info] && !@in_directive
+        if node.options[:debug_info]
           to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
-        elsif node.options[:trace_selectors]
-          to_return << "#{old_spaces}/* "
-          to_return << node.stack_trace.join("\n   #{old_spaces}")
-          to_return << " */\n"
         elsif node.options[:line_comments]
           to_return << "#{old_spaces}/* line #{node.line}"
 
@@ -198,7 +196,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   def debug_info_rule(debug_info, options)
     node = Sass::Tree::DirectiveNode.new("@media -sass-debug-info")
-    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).each do |k, v|
+    debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(
@@ -206,7 +204,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
                 [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)])
             ])
         ])
-      prop = Sass::Tree::PropNode.new([""], Sass::Script::String.new(''), :new)
+      prop = Sass::Tree::PropNode.new([""], "", :new)
       prop.resolved_name = "font-family"
       prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
       rule << prop

data/lib/sass/tree/warn_node.rb

@@ -6,7 +6,7 @@ module Sass
     class WarnNode < Node
       # The expression to print.
       # @return [Script::Node]
-      attr_accessor :expr
+      attr_reader :expr
 
       # @param expr [Script::Node] The expression to print
       def initialize(expr)

data/lib/sass/tree/while_node.rb

@@ -7,7 +7,7 @@ module Sass::Tree
   class WhileNode < Node
     # The parse tree for the continuation expression.
     # @return [Script::Node]
-    attr_accessor :expr
+    attr_reader :expr
 
     # @param expr [Script::Node] See \{#expr}
     def initialize(expr)

data/lib/sass/util.rb

@@ -2,6 +2,7 @@ require 'erb'
 require 'set'
 require 'enumerator'
 require 'stringio'
+require 'strscan'
 require 'rbconfig'
 
 require 'sass/root'
@@ -85,9 +86,8 @@ module Sass
     # @return [Hash] The mapped hash
     # @see #map_keys
     # @see #map_vals
-    def map_hash(hash)
-      # Using &block here completely hoses performance on 1.8.
-      to_hash(hash.map {|k, v| yield k, v})
+    def map_hash(hash, &block)
+      to_hash(hash.map(&block))
     end
 
     # Computes the powerset of the given array.
@@ -219,57 +219,6 @@ module Sass
       lcs_backtrace(lcs_table(x, y, &block), x, y, x.size-1, y.size-1, &block)
     end
 
-    # Converts a Hash to an Array. This is usually identical to `Hash#to_a`,
-    # with the following exceptions:
-    #
-    # * In Ruby 1.8, `Hash#to_a` is not deterministically ordered, but this is.
-    # * In Ruby 1.9 when running tests, this is ordered in the same way it would
-    #   be under Ruby 1.8 (sorted key order rather than insertion order).
-    #
-    # @param hash [Hash]
-    # @return [Array]
-    def hash_to_a(hash)
-      return hash.to_a unless ruby1_8? || defined?(Test::Unit)
-      return hash.sort_by {|k, v| k}
-    end
-
-    # Asserts that `value` falls within `range` (inclusive), leaving
-    # room for slight floating-point errors.
-    #
-    # @param name [String] The name of the value. Used in the error message.
-    # @param range [Range] The allowed range of values.
-    # @param value [Numeric, Sass::Script::Number] The value to check.
-    # @param unit [String] The unit of the value. Used in error reporting.
-    # @return [Numeric] `value` adjusted to fall within range, if it
-    #   was outside by a floating-point margin.
-    def check_range(name, range, value, unit='')
-      grace = (-0.00001..0.00001)
-      str = value.to_s
-      value = value.value if value.is_a?(Sass::Script::Number)
-      return value if range.include?(value)
-      return range.first if grace.include?(value - range.first)
-      return range.last if grace.include?(value - range.last)
-      raise ArgumentError.new(
-        "#{name} #{str} must be between #{range.first}#{unit} and #{range.last}#{unit}")
-    end
-
-    # Returns whether or not `seq1` is a subsequence of `seq2`. That is, whether
-    # or not `seq2` contains every element in `seq1` in the same order (and
-    # possibly more elements besides).
-    #
-    # @param seq1 [Array]
-    # @param seq2 [Array]
-    # @return [Boolean]
-    def subsequence?(seq1, seq2)
-      i = j = 0
-      loop do
-        return true if i == seq1.size
-        return false if j == seq2.size
-        i += 1 if seq1[i] == seq2[j]
-        j += 1
-      end
-    end
-
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -344,17 +293,19 @@ module Sass
     #
     # @yield A block in which no Sass warnings will be printed
     def silence_sass_warnings
-      old_level, Sass.logger.log_level = Sass.logger.log_level, :error
+      old_silence_warnings = @@silence_warnings
+      @@silence_warnings = true
       yield
     ensure
-      Sass.logger.log_level = old_level
+      @@silence_warnings = old_silence_warnings
     end
 
     # The same as `Kernel#warn`, but is silenced by \{#silence\_sass\_warnings}.
     #
     # @param msg [String]
     def sass_warn(msg)
-      Sass.logger.warn(msg)
+      return if @@silence_warnings
+      warn(msg)
     end
 
     ## Cross Rails Version Compatibility
@@ -436,14 +387,6 @@ module Sass
       RUBY_ENGINE == "ironruby"
     end
 
-    # Like `Dir.glob`, but works with backslash-separated paths on Windows.
-    #
-    # @param path [String]
-    def glob(path, &block)
-      path = path.gsub('\\', '/') if windows?
-      Dir.glob(path, &block)
-    end
-
     ## Cross-Ruby-Version Compatibility
 
     # Whether or not this is running under Ruby 1.8 or lower.
@@ -466,13 +409,6 @@ module Sass
       ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
     end
 
-    # Whether or not this is running under MacRuby.
-    #
-    # @return [Boolean]
-    def macruby?
-      RUBY_ENGINE == 'macruby'
-    end
-
     # Checks that the encoding of a string is valid in Ruby 1.9
     # and cleans up potential encoding gotchas like the UTF-8 BOM.
     # If it's not, yields an error string describing the invalid character
@@ -533,8 +469,7 @@ MSG
       # We allow any printable ASCII characters but double quotes in the charset decl
       bin = str.dup.force_encoding("BINARY")
       encoding = Sass::Util::ENCODINGS_TO_CHECK.find do |enc|
-        re = Sass::Util::CHARSET_REGEXPS[enc]
-        re && bin =~ re
+        bin =~ Sass::Util::CHARSET_REGEXPS[enc]
       end
       charset, bom = $1, $2
       if charset
@@ -575,8 +510,6 @@ MSG
             Regexp.new(/\A(?:#{_enc("\uFEFF", e)})?#{
               _enc('@charset "', e)}(.*?)#{_enc('"', e)}|\A(#{
               _enc("\uFEFF", e)})/)
-          rescue Encoding::ConverterNotFoundError => _
-            nil # JRuby on Java 5 doesn't support UTF-32
           rescue
             # /\A@charset "(.*?)"/
             Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/)
@@ -628,24 +561,6 @@ MSG
       ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
     end
 
-    # Destructively removes all elements from an array that match a block, and
-    # returns the removed elements.
-    #
-    # @param array [Array] The array from which to remove elements.
-    # @yield [el] Called for each element.
-    # @yieldparam el [*] The element to test.
-    # @yieldreturn [Boolean] Whether or not to extract the element.
-    # @return [Array] The extracted elements.
-    def extract!(array)
-      out = []
-      array.reject! do |e|
-        next false unless yield e
-        out << e
-        true
-      end
-      out
-    end
-
     # Returns the ASCII code of the given character.
     #
     # @param c [String] All characters but the first are ignored.
@@ -699,57 +614,6 @@ MSG
       '"' + obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]} + '"'
     end
 
-    # Extracts the non-string vlaues from an array containing both strings and non-strings.
-    # These values are replaced with escape sequences.
-    # This can be undone using \{#inject\_values}.
-    #
-    # This is useful e.g. when we want to do string manipulation
-    # on an interpolated string.
-    #
-    # The precise format of the resulting string is not guaranteed.
-    # However, it is guaranteed that newlines and whitespace won't be affected.
-    #
-    # @param arr [Array] The array from which values are extracted.
-    # @return [(String, Array)] The resulting string, and an array of extracted values.
-    def extract_values(arr)
-      values = []
-      return arr.map do |e|
-        next e.gsub('{', '{{') if e.is_a?(String)
-        values << e
-        next "{#{values.count - 1}}"
-      end.join, values
-    end
-
-    # Undoes \{#extract\_values} by transforming a string with escape sequences
-    # into an array of strings and non-string values.
-    #
-    # @param str [String] The string with escape sequences.
-    # @param values [Array] The array of values to inject.
-    # @return [Array] The array of strings and values.
-    def inject_values(str, values)
-      return [str.gsub('{{', '{')] if values.empty?
-      # Add an extra { so that we process the tail end of the string
-      result = (str + '{{').scan(/(.*?)(?:(\{\{)|\{(\d+)\})/m).map do |(pre, esc, n)|
-        [pre, esc ? '{' : '', n ? values[n.to_i] : '']
-      end.flatten(1)
-      result[-2] = '' # Get rid of the extra {
-      merge_adjacent_strings(result).reject {|s| s == ''}
-    end
-
-    # Allows modifications to be performed on the string form
-    # of an array containing both strings and non-strings.
-    #
-    # @param arr [Array] The array from which values are extracted.
-    # @yield [str] A block in which string manipulation can be done to the array.
-    # @yieldparam str [String] The string form of `arr`.
-    # @yieldreturn [String] The modified string.
-    # @return [Array] The modified, interpolated array.
-    def with_extracted_values(arr)
-      str, vals = extract_values(arr)
-      str = yield str
-      inject_values(str, vals)
-    end
-
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.
@@ -803,5 +667,3 @@ MSG
     end
   end
 end
-
-require 'sass/util/multibyte_string_scanner'