sass 3.4.25 → 3.5.0

data/lib/sass/selector/sequence.rb

@@ -66,10 +66,14 @@ module Sass
           next [sseq_or_op] unless sseq_or_op.is_a?(SimpleSequence)
           sseq_or_op.resolve_parent_refs(super_cseq).members
         end).map do |path|
-          Sequence.new(path.map do |seq_or_op|
+          path_members = path.map do |seq_or_op|
             next seq_or_op unless seq_or_op.is_a?(Sequence)
             seq_or_op.members
-          end.flatten)
+          end
+          if path_members.length == 2 && path_members[1][0] == "\n"
+            path_members[0].unshift path_members[1].shift
+          end
+          Sequence.new(path_members.flatten)
         end)
       end
 
@@ -115,7 +119,7 @@ module Sass
           # specificity greater than or equal to that of the original selector.
           # In order to ensure that, we record the original selector's
           # (`extended.first`) original specificity.
-          extended.first.add_sources!([self]) if original && !has_placeholder?
+          extended.first.add_sources!([self]) if original && !invisible?
 
           extended.map {|seq| seq.members}
         end
@@ -283,6 +287,9 @@ module Sass
           next unless s1.first.is_a?(SimpleSequence) && s2.first.is_a?(SimpleSequence)
           next s2 if parent_superselector?(s1, s2)
           next s1 if parent_superselector?(s2, s1)
+          next unless must_unify?(s1, s2)
+          next unless (unified = Sequence.new(s1).unify(Sequence.new(s2)))
+          unified.members.first.members if unified.members.length == 1
         end
 
         diff = [[init]]
@@ -494,7 +501,7 @@ module Sass
         return if seq1.size > seq2.size
         return seq1.first.superselector?(seq2.last, seq2[0...-1]) if seq1.size == 1
 
-        _, si = Sass::Util.enum_with_index(seq2).find do |e, i|
+        _, si = seq2.each_with_index.find do |e, i|
           return if i == seq2.size - 1
           next if e.is_a?(String)
           seq1.first.superselector?(e, seq2[0...i])
@@ -537,6 +544,30 @@ module Sass
         _superselector?(seq1 + [base], seq2 + [base])
       end
 
+      # Returns whether two selectors must be unified to produce a valid
+      # combined selector. This is true when both selectors contain the same
+      # unique simple selector such as an id.
+      #
+      # @param seq1 [Array<SimpleSequence or String>]
+      # @param seq2 [Array<SimpleSequence or String>]
+      # @return [Boolean]
+      def must_unify?(seq1, seq2)
+        unique_selectors = seq1.map do |sseq|
+          next [] if sseq.is_a?(String)
+          sseq.members.select {|sel| sel.unique?}
+        end.flatten.to_set
+
+        return false if unique_selectors.empty?
+
+        seq2.any? do |sseq|
+          next false if sseq.is_a?(String)
+          sseq.members.any? do |sel|
+            next unless sel.unique?
+            unique_selectors.include?(sel)
+          end
+        end
+      end
+
       # Removes redundant selectors from between multiple lists of
       # selectors. This takes a list of lists of selector sequences;
       # each individual list is assumed to have no redundancy within
@@ -597,8 +628,6 @@ module Sass
         other.members.reject {|m| m == "\n"}.eql?(members.reject {|m| m == "\n"})
       end
 
-      private
-
       def path_has_two_subjects?(path)
         subject = false
         path.each do |sseq_or_op|

data/lib/sass/selector/simple.rb

@@ -14,6 +14,14 @@ module Sass
       # @return [String, nil]
       attr_accessor :filename
 
+      # Whether only one instance of this simple selector is allowed in a given
+      # complex selector.
+      #
+      # @return [Boolean]
+      def unique?
+        false
+      end
+
       # @see #to_s
       #
       # @return [String]
@@ -74,9 +82,8 @@ module Sass
       def unify(sels)
         return sels.first.unify([self]) if sels.length == 1 && sels.first.is_a?(Universal)
         return sels if sels.any? {|sel2| eql?(sel2)}
-        sels_with_ix = Sass::Util.enum_with_index(sels)
         if !is_a?(Pseudo) || (sels.last.is_a?(Pseudo) && sels.last.type == :element)
-          _, i = sels_with_ix.find {|sel, _| sel.is_a?(Pseudo)}
+          _, i = sels.each_with_index.find {|sel, _| sel.is_a?(Pseudo)}
         end
         return sels + [self] unless i
         sels[0...i] + [self] + sels[i..-1]

data/lib/sass/selector/simple_sequence.rb

@@ -163,7 +163,7 @@ module Sass
           next sel if seen.include?([sel])
           extended = sel.selector.do_extend(extends, parent_directives, replace, seen, false)
           next sel if extended == sel.selector
-          extended.members.reject! {|seq| seq.has_placeholder?}
+          extended.members.reject! {|seq| seq.invisible?}
 
           # For `:not()`, we usually want to get rid of any complex
           # selectors because that will cause the selector to fail to
@@ -184,17 +184,16 @@ module Sass
           result
         end.flatten
 
-        groups = Sass::Util.group_by_to_a(extends[members.to_set]) {|ex| ex.extender}
+        groups = extends[members.to_set].group_by {|ex| ex.extender}.to_a
         groups.map! do |seq, group|
           sels = group.map {|e| e.target}.flatten
           # If A {@extend B} and C {...},
           # seq is A, sels is B, and self is C
 
           self_without_sel = Sass::Util.array_minus(members, sels)
-          group.each {|e| e.result = :failed_to_unify unless e.result == :succeeded}
+          group.each {|e| e.success = true}
           unified = seq.members.last.unify(SimpleSequence.new(self_without_sel, subject?))
           next unless unified
-          group.each {|e| e.result = :succeeded}
           group.each {|e| check_directives_match!(e, parent_directives)}
           new_seq = Sequence.new(seq.members[0...-1] + [unified])
           new_seq.add_sources!(sources + [seq])
@@ -287,6 +286,11 @@ module Sass
       # @see Simple#to_s
       def to_s(opts = {})
         res = @members.map {|m| m.to_s(opts)}.join
+
+        # :not(%foo) may resolve to the empty string, but it should match every
+        # selector so we replace it with "*".
+        res = '*' if res.empty?
+
         res << '!' if subject?
         res
       end

data/lib/sass/selector.rb

@@ -87,6 +87,10 @@ module Sass
         @name = name
       end
 
+      def unique?
+        true
+      end
+
       # @see Selector#to_s
       def to_s(opts = {})
         "#" + @name

data/lib/sass/source/map.rb

@@ -93,8 +93,8 @@ module Sass::Source
         raise ArgumentError.new("Sass::Source::Map#to_json requires either " \
           "the :css_uri option or both the :css_path and :soucemap_path options.")
       end
-      css_path &&= Sass::Util.pathname(Sass::Util.absolute_path(css_path))
-      sourcemap_path &&= Sass::Util.pathname(Sass::Util.absolute_path(sourcemap_path))
+      css_path &&= Sass::Util.pathname(File.absolute_path(css_path))
+      sourcemap_path &&= Sass::Util.pathname(File.absolute_path(sourcemap_path))
       css_uri ||= Sass::Util.file_uri_from_path(
         Sass::Util.relative_path_from(css_path, sourcemap_path.dirname))
 

data/lib/sass/stack.rb

@@ -98,8 +98,28 @@ module Sass
       with_frame(filename, line, :mixin, name) {yield}
     end
 
+    # Pushes a function frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_function(filename, line, name)
+      with_frame(filename, line, :function, name) {yield}
+    end
+
+    # Pushes a function frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_directive(filename, line, name)
+      with_frame(filename, line, :directive, name) {yield}
+    end
+
     def to_s
-      Sass::Util.enum_with_index(Sass::Util.enum_cons(frames.reverse + [nil], 2)).
+      (frames.reverse + [nil]).each_cons(2).each_with_index.
           map do |(frame, caller), i|
         "#{i == 0 ? 'on' : 'from'} line #{frame.line}" +
           " of #{frame.filename || 'an unknown file'}" +

data/lib/sass/tree/charset_node.rb

@@ -16,7 +16,7 @@ module Sass::Tree
 
     # @see Node#invisible?
     def invisible?
-      !Sass::Util.ruby1_8?
+      true
     end
   end
 end

data/lib/sass/tree/prop_node.rb

@@ -20,7 +20,11 @@ module Sass::Tree
 
     # The value of the property.
     #
-    # @return [Sass::Script::Tree::Node]
+    # For most properties, this will just contain a single Node. However, for
+    # CSS variables, it will contain multiple strings and nodes representing
+    # interpolation. Any adjacent strings will be merged together.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :value
 
     # The value of the property
@@ -52,14 +56,22 @@ module Sass::Tree
     # @return [Sass::Source::Range]
     attr_accessor :value_source_range
 
+    # Whether this represents a CSS custom property.
+    #
+    # @return [Boolean]
+    def custom_property?
+      name.first.is_a?(String) && name.first.start_with?("--")
+    end
+
     # @param name [Array<String, Sass::Script::Tree::Node>] See \{#name}
-    # @param value [Sass::Script::Tree::Node] See \{#value}
+    # @param value [Array<String, Sass::Script::Tree::Node>] See \{#value}
     # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
     #   `:old` if it uses `:a b`-style syntax
     def initialize(name, value, prop_syntax)
       @name = Sass::Util.strip_string_array(
         Sass::Util.merge_adjacent_strings(name))
-      @value = value
+      @value = Sass::Util.merge_adjacent_strings(value)
+      @value = Sass::Util.strip_string_array(@value) unless custom_property?
       @tabs = 0
       @prop_syntax = prop_syntax
       super()
@@ -81,9 +93,10 @@ module Sass::Tree
     # @return [String] The message
     def pseudo_class_selector_message
       if @prop_syntax == :new ||
-          !value.is_a?(Sass::Script::Tree::Literal) ||
-          !value.value.is_a?(Sass::Script::Value::String) ||
-          !value.value.value.empty?
+          custom_property? ||
+          !value.first.is_a?(Sass::Script::Tree::Literal) ||
+          !value.first.value.is_a?(Sass::Script::Value::String) ||
+          !value.first.value.value.empty?
         return ""
       end
 
@@ -98,73 +111,52 @@ module Sass::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
+      value = self.value.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
+      value = "(#{value})" if value_needs_parens?
+
       if name[0] == ?:
-        raise Sass::SyntaxError.new("The \"#{name}: #{self.class.val_to_sass(value, opts)}\"" +
+        raise Sass::SyntaxError.new("The \"#{name}: #{value}\"" +
                                     " hack is not allowed in the Sass indented syntax")
       end
 
+      # The indented syntax doesn't support newlines in custom property values,
+      # but we can losslessly convert them to spaces instead.
+      value = value.tr("\n", " ") if fmt == :sass
+
       old = opts[:old] && fmt == :sass
-      initial = old ? ':' : ''
-      mid = old ? '' : ':'
-      "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
+      "#{old ? ':' : ''}#{name}#{old ? '' : ':'}#{custom_property? ? '' : ' '}#{value}".rstrip
     end
 
     # A property node is invisible if its value is empty.
     #
     # @return [Boolean]
     def invisible?
-      resolved_value.empty?
+      !custom_property? && resolved_value.empty?
     end
 
     private
 
+    # Returns whether \{#value} neesd parentheses in order to be parsed
+    # properly as division.
+    def value_needs_parens?
+      return false if custom_property?
+
+      root = value.first
+      root.is_a?(Sass::Script::Tree::Operation) &&
+        root.operator == :div &&
+        root.operand1.is_a?(Sass::Script::Tree::Literal) &&
+        root.operand1.value.is_a?(Sass::Script::Value::Number) &&
+        root.operand1.value.original.nil? &&
+        root.operand2.is_a?(Sass::Script::Tree::Literal) &&
+        root.operand2.value.is_a?(Sass::Script::Value::Number) &&
+        root.operand2.value.original.nil?
+    end
+
     def check!
       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
-      # @private
-      def val_to_sass(value, opts)
-        val_to_sass_comma(value, opts).to_sass(opts)
-      end
-
-      private
-
-      def val_to_sass_comma(node, opts)
-        return node unless node.is_a?(Sass::Script::Tree::Operation)
-        return val_to_sass_concat(node, opts) unless node.operator == :comma
-
-        Sass::Script::Tree::Operation.new(
-          val_to_sass_concat(node.operand1, opts),
-          val_to_sass_comma(node.operand2, opts),
-          node.operator)
-      end
-
-      def val_to_sass_concat(node, opts)
-        return node unless node.is_a?(Sass::Script::Tree::Operation)
-        return val_to_sass_div(node, opts) unless node.operator == :space
-
-        Sass::Script::Tree::Operation.new(
-          val_to_sass_div(node.operand1, opts),
-          val_to_sass_concat(node.operand2, opts),
-          node.operator)
-      end
-
-      def val_to_sass_div(node, opts)
-        unless node.is_a?(Sass::Script::Tree::Operation) && node.operator == :div &&
-            node.operand1.is_a?(Sass::Script::Tree::Literal) &&
-            node.operand1.value.is_a?(Sass::Script::Value::Number) &&
-            node.operand2.is_a?(Sass::Script::Tree::Literal) &&
-            node.operand2.value.is_a?(Sass::Script::Value::Number) &&
-            (!node.operand1.value.original || !node.operand2.value.original)
-          return node
-        end
-
-        Sass::Script::Value::String.new("(#{node.to_sass(opts)})")
-      end
-    end
   end
 end

data/lib/sass/tree/rule_node.rb

@@ -120,13 +120,14 @@ module Sass::Tree
     #
     # @return [{#to_s => #to_s}]
     def debug_info
-      {:filename => filename && ("file://" + Sass::Util.escape_uri(File.expand_path(filename))),
+      {:filename => filename &&
+         ("file://" + URI::DEFAULT_PARSER.escape(File.expand_path(filename))),
        :line => line}
     end
 
     # A rule node is invisible if it has only placeholder selectors.
     def invisible?
-      resolved_rules.members.all? {|seq| seq.has_placeholder?}
+      resolved_rules.members.all? {|seq| seq.invisible?}
     end
 
     private

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

@@ -31,7 +31,7 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     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).
+      @parent = @parents.reverse.each_with_index.
         find {|p, i| !transparent_parent?(p, @parents[-i - 2])}.first
 
       begin

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

@@ -203,8 +203,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
     unless node.args.empty? && node.keywords.empty? && node.splat.nil?
       args = node.args.map(&arg_to_sass)
-      keywords = Sass::Util.hash_to_a(node.keywords.as_stored).
-        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
+      keywords = node.keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
 
       if node.splat
         splat = "#{arg_to_sass[node.splat]}..."
@@ -281,7 +280,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   # 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|
+    (nodes + [nil]).each_cons(2).map do |child, nxt|
       visit(child) +
         if nxt &&
             (child.is_a?(Sass::Tree::CommentNode) && child.line + child.lines + 1 == nxt.line) ||

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

@@ -56,8 +56,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     @parents.pop
   end
 
-  # In Ruby 1.8, ensures that there's only one `@charset` directive
-  # and that it's at the top of the document.
+  # Converts the entire document to CSS.
   #
   # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
   #   *and* the extensions defined for this tree
@@ -65,14 +64,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     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_to_move = []
       import_limit = nil
       i = -1
@@ -115,11 +106,9 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # @attr node [Sass::Tree::ExtendNode] The node that produced this extend.
   # @attr directives [Array<Sass::Tree::DirectiveNode>]
   #   The directives containing the `@extend`.
-  # @attr result [Symbol]
-  #   The result of this extend. One of `:not_found` (the target doesn't exist
-  #   in the document), `:failed_to_unify` (the target exists but cannot be
-  #   unified with the extender), or `:succeeded`.
-  Extend = Struct.new(:extender, :target, :node, :directives, :result)
+  # @attr success [Boolean]
+  #   Whether this extend successfully matched a selector.
+  Extend = Struct.new(:extender, :target, :node, :directives, :success)
 
   # Registers an extension in the `@extends` subset map.
   def visit_extend(node)

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

@@ -61,7 +61,7 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
 
   def visit_prop(node)
     node.name = node.name.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}
-    node.value = node.value.deep_copy
+    node.value = node.value.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}
     yield
   end
 

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

@@ -49,19 +49,13 @@ class Sass::Tree::Visitors::Extend < Sass::Tree::Visitors::Base
 
     def check_extends_fired!(extends)
       extends.each_value do |ex|
-        next if ex.result == :succeeded || ex.node.optional?
+        next if ex.success || ex.node.optional?
         message = "\"#{ex.extender}\" failed to @extend \"#{ex.target.join}\"."
-        reason =
-          if ex.result == :not_found
-            "The selector \"#{ex.target.join}\" was not found."
-          else
-            "No selectors matching \"#{ex.target.join}\" could be unified with \"#{ex.extender}\"."
-          end
 
         # TODO(nweiz): this should use the Sass stack trace of the extend node.
         raise Sass::SyntaxError.new(<<MESSAGE, :filename => ex.node.filename, :line => ex.node.line)
 #{message}
-#{reason}
+The selector "#{ex.target.join}" was not found.
 Use "@extend #{ex.target.join} !optional" if the extend should be able to fail.
 MESSAGE
       end

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

@@ -290,7 +290,7 @@ WARNING
 
     @environment.set_local_function(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, false, "function"))
+                         node.children, false, "function", :stylesheet))
     []
   end
 
@@ -341,7 +341,7 @@ WARNING
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_mixin(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, node.has_content, "mixin"))
+                         node.children, node.has_content, "mixin", :stylesheet))
     []
   end
 
@@ -395,9 +395,19 @@ WARNING
   # 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
-    node.value_source_range = val.source_range if val.source_range
+
+    # If the node's value is just a variable or similar, we may get a useful
+    # source range from evaluating it.
+    if node.value.length == 1 && node.value.first.is_a?(Sass::Script::Tree::Node)
+      result = node.value.first.perform(@environment)
+      node.resolved_value = result.to_s
+      node.value_source_range = result.source_range if result.source_range
+    elsif node.custom_property?
+      node.resolved_value = run_interp_no_strip(node.value)
+    else
+      node.resolved_value = run_interp(node.value)
+    end
+
     yield
   end
 
@@ -483,9 +493,11 @@ WARNING
   def visit_warn(node)
     res = node.expr.perform(@environment)
     res = res.value if res.is_a?(Sass::Script::Value::String)
-    msg = "WARNING: #{res}\n         "
-    msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
-    Sass::Util.sass_warn msg
+    @environment.stack.with_directive(node.filename, node.line, "@warn") do
+      msg = "WARNING: #{res}\n         "
+      msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
+      Sass::Util.sass_warn msg
+    end
     []
   end
 
@@ -556,7 +568,7 @@ WARNING
     end
 
     files << node.filename << node.imported_file.options[:filename]
-    msg << "\n" << Sass::Util.enum_cons(files, 2).map do |m1, m2|
+    msg << "\n" << files.each_cons(2).map do |m1, m2|
       "    #{m1} imports #{m2}"
     end.join("\n")
     raise Sass::SyntaxError.new(msg)

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

@@ -88,7 +88,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
 
   def visit_prop(node)
     node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
-    node.value.options = @options
+    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 

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

@@ -135,7 +135,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
     output "\n"
 
-    unless Sass::Util.ruby1_8? || @result.ascii_only?
+    unless @result.ascii_only?
       if node.style == :compressed
         # A byte order mark is sufficient to tell browsers that this
         # file is UTF-8 encoded, and will override any other detection
@@ -261,18 +261,20 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   end
 
   def visit_prop(node)
-    return if node.resolved_value.empty?
+    return if node.resolved_value.empty? && !node.custom_property?
     tab_str = '  ' * (@tabs + node.tabs)
     output(tab_str)
     for_node(node, :name) {output(node.resolved_name)}
-    if node.style == :compressed
-      output(":")
-      for_node(node, :value) {output(node.resolved_value)}
-    else
-      output(": ")
-      for_node(node, :value) {output(node.resolved_value)}
-      output(";")
+    output(":")
+    output(" ") unless node.style == :compressed || node.custom_property?
+    for_node(node, :value) do
+      output(if node.custom_property?
+               format_custom_property_value(node)
+             else
+               node.resolved_value
+             end)
     end
+    output(";") unless node.style == :compressed
   end
 
   # @comment
@@ -294,8 +296,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
                                       end
 
       joined_rules = node.resolved_rules.members.map do |seq|
-        next if seq.has_placeholder?
-        rule_part = seq.to_s(:style => node.style)
+        next if seq.invisible?
+        rule_part = seq.to_s(style: node.style, placeholder: false)
         if node.style == :compressed
           rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
           rule_part.gsub!(/\s*([+>])\s*/m, '\1')
@@ -384,9 +386,41 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   private
 
+  # Reformats the value of `node` so that it's nicely indented, preserving its
+  # existing relative indentation.
+  #
+  # @param node [Sass::Script::Tree::PropNode] A custom property node.
+  # @return [String]
+  def format_custom_property_value(node)
+    if node.style == :compact || node.style == :compressed || !node.resolved_value.include?("\n")
+      # Folding not involving newlines was done in the parser. We can safely
+      # fold newlines here because tokens like strings can't contain literal
+      # newlines, so we know any adjacent whitespace is tokenized as whitespace.
+      return node.resolved_value.gsub(/[ \t\r\f]*\n[ \t\r\f\n]*/, ' ')
+    end
+
+    # Find the smallest amount of indentation in the custom property and use
+    # that as the base indentation level.
+    lines = node.resolved_value.split("\n")
+    indented_lines = lines[1..-1]
+    min_indentation = indented_lines.
+      map {|line| line[/^[ \t]*/]}.
+      reject {|line| line.empty?}.
+      min_by {|line| line.length}
+
+    # Limit the base indentation to the same indentation level as the node name
+    # so that if *every* line is indented relative to the property name that's
+    # preserved.
+    if node.name_source_range
+      base_indentation = min_indentation[0...node.name_source_range.start_pos.offset - 1]
+    end
+
+    lines.first + "\n" + indented_lines.join("\n").gsub(/^#{base_indentation}/, '  ' * @tabs)
+  end
+
   def debug_info_rule(debug_info, options)
     node = Sass::Tree::DirectiveNode.resolved("@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]}.to_a.each do |k, v|
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(
@@ -395,7 +429,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
             false)
           ])
         ])
-      prop = Sass::Tree::PropNode.new([""], Sass::Script::Value::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