sass 3.3.0 → 3.4.25

data/lib/sass/tree/directive_node.rb

@@ -1,5 +1,5 @@
 module Sass::Tree
-  # A static node representing an unproccessed Sass `@`-directive.
+  # A static node representing an unprocessed Sass `@`-directive.
   # Directives known to Sass, like `@for` and `@debug`,
   # are handled by their own nodes;
   # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
@@ -43,7 +43,13 @@ module Sass::Tree
 
     # @return [String] The name of the directive, including `@`.
     def name
-      value.first.gsub(/ .*$/, '')
+      @name ||= value.first.gsub(/ .*$/, '')
+    end
+
+    # Strips out any vendor prefixes and downcases the directive name.
+    # @return [String] The normalized name of the directive.
+    def normalized_name
+      @normalized_name ||= name.gsub(/^(@)(?:-[a-zA-Z0-9]+-)?/, '\1').downcase
     end
 
     def bubbles?

data/lib/sass/tree/error_node.rb

@@ -0,0 +1,18 @@
+module Sass
+  module Tree
+    # A dynamic node representing a Sass `@error` statement.
+    #
+    # @see Sass::Tree
+    class ErrorNode < Node
+      # The expression to print.
+      # @return [Script::Tree::Node]
+      attr_accessor :expr
+
+      # @param expr [Script::Tree::Node] The expression to print
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
+    end
+  end
+end

data/lib/sass/tree/extend_node.rb

@@ -1,7 +1,7 @@
 require 'sass/tree/node'
 
 module Sass::Tree
-  # A static node reprenting an `@extend` directive.
+  # A static node representing an `@extend` directive.
   #
   # @see Sass::Tree
   class ExtendNode < Node

data/lib/sass/tree/function_node.rb

@@ -20,6 +20,12 @@ module Sass
       # @return [Script::Tree::Node?]
       attr_accessor :splat
 
+      # Strips out any vendor prefixes.
+      # @return [String] The normalized name of the directive.
+      def normalized_name
+        @normalized_name ||= name.gsub(/^(?:-[a-zA-Z0-9]+-)?/, '\1')
+      end
+
       # @param name [String] The function name
       # @param args [Array<(Script::Tree::Node, Script::Tree::Node)>]
       #   The arguments for the function.
@@ -29,6 +35,9 @@ module Sass
         @args = args
         @splat = splat
         super()
+
+        return unless %w(and or not).include?(name)
+        raise Sass::SyntaxError.new("Invalid function name \"#{name}\".")
       end
     end
   end

data/lib/sass/tree/import_node.rb

@@ -55,13 +55,14 @@ module Sass
           return f if f
         end
 
-        message = "File to import not found or unreadable: #{@imported_filename}.\n"
+        lines = ["File to import not found or unreadable: #{@imported_filename}."]
+
         if paths.size == 1
-          message << "Load path: #{paths.first}"
-        else
-          message << "Load paths:\n  " << paths.join("\n  ")
+          lines << "Load path: #{paths.first}"
+        elsif !paths.empty?
+          lines << "Load paths:\n  #{paths.join("\n  ")}"
         end
-        raise SyntaxError.new(message)
+        raise SyntaxError.new(lines.join("\n"))
       rescue SyntaxError => e
         raise SyntaxError.new(e.message, :line => line, :filename => @filename)
       end

data/lib/sass/tree/keyframe_rule_node.rb

@@ -0,0 +1,15 @@
+module Sass::Tree
+  class KeyframeRuleNode < Node
+    # The text of the directive after any interpolated SassScript has been resolved.
+    # Since this is only a static node, this is the only value property.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # @param resolved_value [String] See \{#resolved_value}
+    def initialize(resolved_value)
+      @resolved_value = resolved_value
+      super()
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -69,7 +69,7 @@ module Sass
 
       # The line of the document on which this node appeared.
       #
-      # @return [Fixnum]
+      # @return [Integer]
       attr_accessor :line
 
       # The source range in the document on which this node appeared.
@@ -83,13 +83,15 @@ module Sass
       attr_writer :filename
 
       # The options hash for the node.
-      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
       #
       # @return [{Symbol => Object}]
       attr_reader :options
 
       def initialize
         @children = []
+        @filename = nil
+        @options = nil
       end
 
       # Sets the options hash for the node and all its children.
@@ -149,7 +151,7 @@ module Sass
       # @return [Boolean]
       def invisible?; false; end
 
-      # The output style. See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # The output style. See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
       #
       # @return [Symbol]
       def style

data/lib/sass/tree/prop_node.rb

@@ -39,7 +39,7 @@ module Sass::Tree
     # * This is a child property of another property
     # * The parent property has a value, and thus will be rendered
     #
-    # @return [Fixnum]
+    # @return [Integer]
     attr_accessor :tabs
 
     # The source range in which the property name appears.
@@ -97,7 +97,7 @@ module Sass::Tree
     # @param opts [{Symbol => Object}] The options hash for the tree.
     # @param fmt [Symbol] `:scss` or `:sass`.
     def declaration(opts = {:old => @prop_syntax == :old}, fmt = :sass)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
+      name = self.name.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
       if name[0] == ?:
         raise Sass::SyntaxError.new("The \"#{name}: #{self.class.val_to_sass(value, opts)}\"" +
                                     " hack is not allowed in the Sass indented syntax")
@@ -119,11 +119,10 @@ module Sass::Tree
     private
 
     def check!
-      if @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
-        raise Sass::SyntaxError.new(
-          "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
-          ":property_syntax => #{@options[:property_syntax].inspect} is set.")
-      end
+      return unless @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
+      raise Sass::SyntaxError.new(
+        "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
+        ":property_syntax => #{@options[:property_syntax].inspect} is set.")
     end
 
     class << self

data/lib/sass/tree/rule_node.rb

@@ -1,7 +1,7 @@
 require 'pathname'
 
 module Sass::Tree
-  # A static node reprenting a CSS rule.
+  # A static node representing a CSS rule.
   #
   # @see Sass::Tree
   class RuleNode < Node
@@ -40,7 +40,7 @@ module Sass::Tree
     # * This is a child rule of another rule
     # * The parent rule has properties, and thus will be rendered
     #
-    # @return [Fixnum]
+    # @return [Integer]
     attr_accessor :tabs
 
     # The entire selector source range for this rule.
@@ -60,15 +60,20 @@ module Sass::Tree
     # @return [String]
     attr_accessor :stack_trace
 
-    # @param rule [Array<String, Sass::Script::Tree::Node>]
+    # @param rule [Array<String, Sass::Script::Tree::Node>, Sass::Selector::CommaSequence]
+    #   The CSS rule, either unparsed or parsed.
     # @param selector_source_range [Sass::Source::Range]
-    #   The CSS rule. See \{#rule}
     def initialize(rule, selector_source_range = nil)
-      merged = Sass::Util.merge_adjacent_strings(rule)
-      @rule = Sass::Util.strip_string_array(merged)
+      if rule.is_a?(Sass::Selector::CommaSequence)
+        @rule = [rule.to_s]
+        @parsed_rules = rule
+      else
+        merged = Sass::Util.merge_adjacent_strings(rule)
+        @rule = Sass::Util.strip_string_array(merged)
+        try_to_parse_non_interpolated_rules
+      end
       @selector_source_range = selector_source_range
       @tabs = 0
-      try_to_parse_non_interpolated_rules
       super()
     end
 
@@ -127,14 +132,24 @@ module Sass::Tree
     private
 
     def try_to_parse_non_interpolated_rules
-      if @rule.all? {|t| t.kind_of?(String)}
-        # We don't use real filename/line info because we don't have it yet.
-        # When we get it, we'll set it on the parsed rules if possible.
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, '', nil, 1)
+      @parsed_rules = nil
+      return unless @rule.all? {|t| t.is_a?(String)}
+
+      # We don't use real filename/line info because we don't have it yet.
+      # When we get it, we'll set it on the parsed rules if possible.
+      parser = nil
+      warnings = Sass::Util.silence_warnings do
+        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
         # rubocop:disable RescueModifier
         @parsed_rules = parser.parse_selector rescue nil
         # rubocop:enable RescueModifier
+
+        $stderr.string
       end
+
+      # If parsing produces a warning, throw away the result so we can parse
+      # later with the real filename info.
+      @parsed_rules = nil unless warnings.empty?
     end
   end
 end

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

@@ -4,6 +4,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   def initialize
     @parents = []
+    @parent = nil
+    @current_mixin_def = nil
   end
 
   def visit(node)
@@ -23,13 +25,34 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   SCRIPT_NODES = [Sass::Tree::ImportNode] + CONTROL_NODES
   def visit_children(parent)
     old_parent = @parent
-    @parent = parent unless is_any_of?(parent, SCRIPT_NODES) ||
-      (parent.bubbles? && !old_parent.is_a?(Sass::Tree::RootNode))
+
+    # When checking a static tree, resolve at-roots to be sure they won't send
+    # nodes where they don't belong.
+    if parent.is_a?(Sass::Tree::AtRootNode) && parent.resolved_value
+      old_parents = @parents
+      @parents = @parents.reject {|p| parent.exclude_node?(p)}
+      @parent = Sass::Util.enum_with_index(@parents.reverse).
+        find {|p, i| !transparent_parent?(p, @parents[-i - 2])}.first
+
+      begin
+        return super
+      ensure
+        @parents = old_parents
+        @parent = old_parent
+      end
+    end
+
+    unless transparent_parent?(parent, old_parent)
+      @parent = parent
+    end
+
     @parents.push parent
-    super
-  ensure
-    @parent = old_parent
-    @parents.pop
+    begin
+      super
+    ensure
+      @parent = old_parent
+      @parents.pop
+    end
   end
 
   def visit_root(node)
@@ -69,9 +92,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   VALID_EXTEND_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::MixinDefNode, Sass::Tree::MixinNode]
   def invalid_extend_parent?(parent, child)
-    unless is_any_of?(parent, VALID_EXTEND_PARENTS)
-      return "Extend directives may only be used within rules."
-    end
+    return if is_any_of?(parent, VALID_EXTEND_PARENTS)
+    "Extend directives may only be used within rules."
   end
 
   INVALID_IMPORT_PARENTS = CONTROL_NODES +
@@ -89,44 +111,38 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   end
 
   def invalid_mixindef_parent?(parent, child)
-    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-      return "Mixins may not be defined within control directives or other mixins."
-    end
+    return if (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+    "Mixins may not be defined within control directives or other mixins."
   end
 
   def invalid_function_parent?(parent, child)
-    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
-      return "Functions may not be defined within control directives or other mixins."
-    end
+    return if (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+    "Functions may not be defined within control directives or other mixins."
   end
 
   VALID_FUNCTION_CHILDREN = [
     Sass::Tree::CommentNode,  Sass::Tree::DebugNode, Sass::Tree::ReturnNode,
-    Sass::Tree::VariableNode, Sass::Tree::WarnNode
+    Sass::Tree::VariableNode, Sass::Tree::WarnNode, Sass::Tree::ErrorNode
   ] + CONTROL_NODES
   def invalid_function_child?(parent, child)
-    unless is_any_of?(child, VALID_FUNCTION_CHILDREN)
-      "Functions can only contain variable declarations and control directives."
-    end
+    return if is_any_of?(child, VALID_FUNCTION_CHILDREN)
+    "Functions can only contain variable declarations and control directives."
   end
 
-  VALID_PROP_CHILDREN =  CONTROL_NODES + [Sass::Tree::CommentNode,
-                                          Sass::Tree::PropNode,
-                                          Sass::Tree::MixinNode]
+  VALID_PROP_CHILDREN = CONTROL_NODES + [Sass::Tree::CommentNode,
+                                         Sass::Tree::PropNode,
+                                         Sass::Tree::MixinNode]
   def invalid_prop_child?(parent, child)
-    unless is_any_of?(child, VALID_PROP_CHILDREN)
-      "Illegal nesting: Only properties may be nested beneath properties."
-    end
+    return if is_any_of?(child, VALID_PROP_CHILDREN)
+    "Illegal nesting: Only properties may be nested beneath properties."
   end
 
-  VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::PropNode,
-                        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode,
-                        Sass::Tree::MixinNode]
+  VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::KeyframeRuleNode, Sass::Tree::PropNode,
+                        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode, Sass::Tree::MixinNode]
   def invalid_prop_parent?(parent, child)
-    unless is_any_of?(parent, VALID_PROP_PARENTS)
-      "Properties are only allowed within rules, directives, mixin includes, or other properties." +
-        child.pseudo_class_selector_message
-    end
+    return if is_any_of?(parent, VALID_PROP_PARENTS)
+    "Properties are only allowed within rules, directives, mixin includes, or other properties." +
+      child.pseudo_class_selector_message
   end
 
   def invalid_return_parent?(parent, child)
@@ -135,6 +151,14 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   private
 
+  # Whether `parent` should be assigned to `@parent`.
+  def transparent_parent?(parent, grandparent)
+    is_any_of?(parent, SCRIPT_NODES) ||
+      (parent.bubbles? &&
+       !grandparent.is_a?(Sass::Tree::RootNode) &&
+       !grandparent.is_a?(Sass::Tree::AtRootNode))
+  end
+
   def is_any_of?(val, classes)
     classes.each do |c|
       return true if val.is_a?(c)

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

@@ -18,15 +18,19 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     @tabs = 0
     # 2 spaces by default
     @tab_chars = @options[:indent] || "  "
+    @is_else = false
   end
 
   def visit_children(parent)
     @tabs += 1
     return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
+
+    res = visit_rule_level(parent.children)
+
     if @format == :sass
-      "\n"  + super.join.rstrip + "\n"
+      "\n" + res.rstrip + "\n"
     else
-      " {\n" + super.join.rstrip + "\n#{ @tab_chars * (@tabs - 1)}}\n"
+      " {\n" + res.rstrip + "\n#{@tab_chars * (@tabs - 1)}}\n"
     end
   ensure
     @tabs -= 1
@@ -34,20 +38,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   # 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.lines + 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"
+    visit_rule_level(node.children)
   end
 
   def visit_charset(node)
@@ -57,14 +48,14 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_comment(node)
     value = interp_to_src(node.value)
     if @format == :sass
-      content = value.gsub(/\*\/$/, '').rstrip
+      content = value.gsub(%r{\*/$}, '').rstrip
       if content =~ /\A[ \t]/
         # Re-indent SCSS comments like this:
         #     /* foo
         #   bar
         #       baz */
         content.gsub!(/^/, '   ')
-        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
+        content.sub!(%r{\A([ \t]*)/\*}, '/*\1')
       end
 
       if content.include?("\n")
@@ -78,13 +69,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
         end
       end
 
-      content.gsub!(/\A\/\*/, '//') if node.type == :silent
+      content.gsub!(%r{\A/\*}, '//') if node.type == :silent
       content.gsub!(/^/, tab_str)
       content = content.rstrip + "\n"
     else
       spaces = (@tab_chars * [@tabs - value[/^ */].size, 0].max)
       content = if node.type == :silent
-                  value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
+                  value.gsub(%r{^[/ ]\*}, '//').gsub(%r{ *\*/$}, '')
                 else
                   value
                 end.gsub(/^/, spaces) + "\n"
@@ -96,11 +87,15 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     "#{tab_str}@debug #{node.expr.to_sass(@options)}#{semi}\n"
   end
 
+  def visit_error(node)
+    "#{tab_str}@error #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
   def visit_directive(node)
     res = "#{tab_str}#{interp_to_src(node.value)}"
     res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2')
     return res + "#{semi}\n" unless node.has_children
-    res + yield + "\n"
+    res + yield
   end
 
   def visit_each(node)
@@ -109,13 +104,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_extend(node)
-    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}" +
-      "#{" !optional" if node.optional?}\n"
+    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}" +
+      "#{' !optional' if node.optional?}#{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}"
+      "#{node.exclusive ? 'to' : 'through'} #{node.to.to_sass(@options)}#{yield}"
   end
 
   def visit_function(node)
@@ -169,6 +164,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     else
       str = "#{tab_str}@import #{node.uri}"
     end
+    str << " supports(#{node.supports_condition.to_src(@options)})" if node.supports_condition
     str << " #{interp_to_src(node.query)}" unless node.query.empty?
     "#{str}#{semi}\n"
   end
@@ -236,12 +232,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_rule(node)
+    rule = node.parsed_rules ? [node.parsed_rules.to_s] : node.rule
     if @format == :sass
-      name = selector_to_sass(node.rule)
+      name = selector_to_sass(rule)
       name = "\\" + name if name[0] == ?:
       name.gsub(/^/, tab_str) + yield
     elsif @format == :scss
-      name = selector_to_scss(node.rule)
+      name = selector_to_scss(rule)
       res = name + yield
       if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.type == :silent
         res.slice!(-3..-1)
@@ -269,35 +266,53 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       "#{tab_str}@at-root #{query_interp_to_src(node.query)}#{yield}"
     elsif node.children.length == 1 && node.children.first.is_a?(Sass::Tree::RuleNode)
       rule = node.children.first
-      "#{tab_str}@at-root #{selector_to_src(rule.rule)}#{visit_children(rule)}"
+      "#{tab_str}@at-root #{selector_to_src(rule.rule).lstrip}#{visit_children(rule)}"
     else
       "#{tab_str}@at-root#{yield}"
     end
   end
 
+  def visit_keyframerule(node)
+    "#{tab_str}#{node.resolved_value}#{yield}"
+  end
+
   private
 
+  # Visit rule-level nodes and return their conversion with appropriate
+  # whitespace added.
+  def visit_rule_level(nodes)
+    Sass::Util.enum_cons(nodes + [nil], 2).map do |child, nxt|
+      visit(child) +
+        if nxt &&
+            (child.is_a?(Sass::Tree::CommentNode) && child.line + child.lines + 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) ||
+            (child.is_a?(Sass::Tree::PropNode) && nxt.is_a?(Sass::Tree::PropNode)) ||
+            (child.is_a?(Sass::Tree::MixinNode) && nxt.is_a?(Sass::Tree::MixinNode) &&
+              child.line + 1 == nxt.line)
+          ""
+        else
+          "\n"
+        end
+    end.join.rstrip + "\n"
+  end
+
   def interp_to_src(interp)
-    interp.map do |r|
-      next r if r.is_a?(String)
-      "\#{#{r.to_sass(@options)}}"
-    end.join
+    interp.map {|r| r.is_a?(String) ? r : r.to_sass(@options)}.join
   end
 
   # Like interp_to_src, but removes the unnecessary `#{}` around the keys and
   # values in query expressions.
   def query_interp_to_src(interp)
-    Sass::Util.enum_with_index(interp).map do |r, i|
-      next r if r.is_a?(String)
-      before, after = interp[i - 1], interp[i + 1]
-      if before.is_a?(String) && after.is_a?(String) &&
-          ((before[-1] == ?( && after[0] == ?:) ||
-           (before =~ /:\s*/ && after[0] == ?)))
-        r.to_sass(@options)
-      else
-        "\#{#{r.to_sass(@options)}}"
-      end
-    end.join
+    interp = interp.map do |e|
+      next e unless e.is_a?(Sass::Script::Tree::Literal)
+      next e unless e.value.is_a?(Sass::Script::Value::String)
+      e.value.value
+    end
+
+    interp_to_src(interp)
   end
 
   def selector_to_src(sel)
@@ -309,7 +324,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       if r.is_a?(String)
         r.gsub(/(,)?([ \t]*)\n\s*/) {$1 ? "#{$1}#{$2}\n" : " "}
       else
-        "\#{#{r.to_sass(@options)}}"
+        r.to_sass(@options)
       end
     end.join
   end
@@ -328,7 +343,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def dasherize(s)
     if @options[:dasherize]
-      s.gsub('_', '-')
+      s.tr('_', '-')
     else
       s
     end