sass 3.3.0.alpha.16 → 3.3.0.alpha.50

data/lib/sass/scss/static_parser.rb

@@ -42,7 +42,7 @@ module Sass
       def interp_ident(ident = IDENT); s = tok(ident) and [s]; end
       def use_css_import?; true; end
 
-      def special_directive(name)
+      def special_directive(name, start_pos)
         return unless %w[media import charset -moz-document].include?(name)
         super
       end

data/lib/sass/source/map.rb

@@ -0,0 +1,159 @@
+require 'pathname'
+
+module Sass::Source
+  class Map
+    # A mapping from one source range to another. Indicates that `input` was
+    # compiled to `output`.
+    #
+    # @!attribute input
+    #   @return [Sass::Source::Range] The source range in the input document.
+    #
+    # @!attribute output
+    #   @return [Sass::Source::Range] The source range in the output document.
+    class Mapping < Struct.new(:input, :output)
+      # @return [String] A string representation of the mapping.
+      def inspect
+        "#{input.inspect} => #{output.inspect}"
+      end
+    end
+
+    # The mapping data ordered by the location in the target.
+    #
+    # @return [Array<Mapping>]
+    attr_reader :data
+
+    def initialize
+      @data = []
+    end
+
+    # Adds a new mapping from one source range to another. Multiple invocations
+    # of this method should have each `output` range come after all previous ranges.
+    #
+    # @param input [Sass::Source::Range]
+    #   The source range in the input document.
+    # @param output [Sass::Source::Range]
+    #   The source range in the output document.
+    def add(input, output)
+      @data.push(Mapping.new(input, output))
+    end
+
+    # Shifts all output source ranges forward one or more lines.
+    #
+    # @param delta [Fixnum] The number of lines to shift the ranges forward.
+    def shift_output_lines(delta)
+      return if delta == 0
+      @data.each do |m|
+        m.output.start_pos.line += delta
+        m.output.end_pos.line += delta
+      end
+    end
+
+    # Shifts any output source ranges that lie on the first line forward one or
+    # more characters on that line.
+    #
+    # @param delta [Fixnum] The number of characters to shift the ranges
+    #   forward.
+    def shift_output_offsets(delta)
+      return if delta == 0
+      @data.each do |m|
+        break if m.output.start_pos.line > 1
+        m.output.start_pos.offset += delta
+        m.output.end_pos.offset += delta if m.output.end_pos.line > 1
+      end
+    end
+
+    # Returns the standard JSON representation of the source map.
+    #
+    # @param target_filename [String] The filename of the output file; that is,
+    #   the target of the mapping. This should be relative to the working
+    #   directory.
+    # @return [String] The JSON string.
+    def to_json(target_filename)
+      result = "{\n"
+      write_json_field(result, "version", "3", true)
+
+      source_pathname_to_id = {}
+      id_to_source_pathname = {}
+      next_source_id = 0
+      line_data = []
+      segment_data_for_line = []
+
+      # These track data necessary for the delta coding.
+      previous_target_line = nil
+      previous_target_offset = 1
+      previous_source_line = 1
+      previous_source_offset = 1
+      previous_source_id = 0
+
+      target_pathname = Pathname.pwd.join(Pathname.new(target_filename)).cleanpath
+      @data.each do |m|
+        source_pathname = Pathname.pwd.join(Pathname.new(m.input.file)).cleanpath
+        source_pathname = source_pathname.relative_path_from(target_pathname.dirname)
+        current_source_id = source_pathname_to_id[source_pathname]
+        unless current_source_id
+          current_source_id = next_source_id
+          next_source_id += 1
+
+          source_pathname_to_id[source_pathname] = current_source_id
+          id_to_source_pathname[current_source_id] = source_pathname
+        end
+
+        [
+          [m.input.start_pos, m.output.start_pos],
+          [m.input.end_pos, m.output.end_pos]
+        ].each do |source_pos, target_pos|
+          if previous_target_line != target_pos.line
+            line_data.push(segment_data_for_line.join(",")) unless segment_data_for_line.empty?
+            (target_pos.line - 1 - (previous_target_line || 0)).times {line_data.push("")}
+            previous_target_line = target_pos.line
+            previous_target_offset = 1
+            segment_data_for_line = []
+          end
+
+          # `segment` is a data chunk for a single position mapping.
+          segment = ""
+
+          # Field 1: zero-based starting offset.
+          segment << Sass::Util.encode_vlq(target_pos.offset - previous_target_offset)
+          previous_target_offset = target_pos.offset
+
+          # Field 2: zero-based index into the "sources" list.
+          segment << Sass::Util.encode_vlq(current_source_id - previous_source_id)
+          previous_source_id = current_source_id
+
+          # Field 3: zero-based starting line in the original source.
+          segment << Sass::Util.encode_vlq(source_pos.line - previous_source_line)
+          previous_source_line = source_pos.line
+
+          # Field 4: zero-based starting offset in the original source.
+          segment << Sass::Util.encode_vlq(source_pos.offset - previous_source_offset)
+          previous_source_offset = source_pos.offset
+
+          segment_data_for_line.push(segment)
+
+          previous_target_line = target_pos.line
+        end
+      end
+      line_data.push(segment_data_for_line.join(","))
+      write_json_field(result, "mappings", line_data.join(";"))
+
+      source_names = []
+      (0...next_source_id).each {|id| source_names.push(id_to_source_pathname[id].to_s)}
+      write_json_field(result, "sources", source_names)
+      write_json_field(result, "file", target_pathname.basename.to_s)
+
+      result << "\n}"
+      result
+    end
+
+    private
+
+    def write_json_field(out, name, value, is_first = false)
+      out << (is_first ? "" : ",\n") <<
+        "\"" <<
+        Sass::Util.json_escape_string(name) <<
+        "\": " <<
+        Sass::Util.json_value_of(value)
+    end
+  end
+end

data/lib/sass/source/position.rb

@@ -0,0 +1,26 @@
+module Sass::Source
+  class Position
+    # The one-based line of the document associated with the position.
+    #
+    # @return [Fixnum]
+    attr_accessor :line
+
+    # The one-based offset in the line of the document associated with the
+    # position.
+    #
+    # @return [Fixnum]
+    attr_accessor :offset
+
+    # @param line [Fixnum] The source line
+    # @param offset [Fixnum] The source offset
+    def initialize(line, offset)
+      @line = line
+      @offset = offset
+    end
+
+    # @return [String] A string representation of the source position.
+    def inspect
+      "#{line.inspect}:#{offset.inspect}"
+    end
+  end
+end

data/lib/sass/source/range.rb

@@ -0,0 +1,34 @@
+module Sass::Source
+  class Range
+    # The starting position of the range in the document (inclusive).
+    #
+    # @return [Sass::Source::Position]
+    attr_accessor :start_pos
+
+    # The ending position of the range in the document (exclusive).
+    #
+    # @return [Sass::Source::Position]
+    attr_accessor :end_pos
+
+    # The file in which this source range appears. This can be nil if the file
+    # is unknown or not yet generated.
+    #
+    # @return [String]
+    attr_accessor :file
+
+    # @param start_pos [Sass::Source::Position] See \{#start_pos}
+    # @param end_pos [Sass::Source::Position] See \{#end_pos}
+    # @param file [String] See \{#file}
+    def initialize(start_pos, end_pos, file)
+      raise 'hell' if end_pos.is_a?(Fixnum)
+      @start_pos = start_pos
+      @end_pos = end_pos
+      @file = file
+    end
+
+    # @return [String] A string representation of the source range.
+    def inspect
+      "(#{start_pos.inspect} to #{end_pos.inspect}#{" in #{@file}" if @file})"
+    end
+  end
+end

data/lib/sass/tree/css_import_node.rb

@@ -30,7 +30,7 @@ module Sass::Tree
 
     # @param uri [String, Sass::Script::Node] See \{#uri}
     # @param query [Array<String, Sass::Script::Node>] See \{#query}
-    def initialize(uri, query = nil)
+    def initialize(uri, query = [])
       @uri = uri
       @query = query
       super('')

data/lib/sass/tree/node.rb

@@ -46,6 +46,11 @@ module Sass
       # @return [Fixnum]
       attr_accessor :line
 
+      # The source range in the document on which this node appeared.
+      #
+      # @return [Sass::Source::Range]
+      attr_accessor :source_range
+
       # The name of the document on which this node appeared.
       #
       # @return [String]
@@ -127,10 +132,21 @@ module Sass
 
       # Computes the CSS corresponding to this static CSS tree.
       #
-      # @return [String, nil] The resulting CSS
+      # @return [String] The resulting CSS
+      # @see Sass::Tree
+      def css
+        Sass::Tree::Visitors::ToCss.new.visit(self)
+      end
+
+      # Computes the CSS corresponding to this static CSS tree, along with
+      # the respective source map.
+      #
+      # @return [(String, Sass::Source::Map)] The resulting CSS and the source map
       # @see Sass::Tree
-      def to_s
-        Sass::Tree::Visitors::ToCss.visit(self)
+      def css_with_sourcemap
+        visitor = Sass::Tree::Visitors::ToCss.new(:build_source_mapping)
+        result = visitor.visit(self)
+        return result, visitor.source_mapping
       end
 
       # Returns a representation of the node for debugging purposes.

data/lib/sass/tree/prop_node.rb

@@ -1,5 +1,5 @@
 module Sass::Tree
-  # A static node reprenting a CSS property.
+  # A static node representing a CSS property.
   #
   # @see Sass::Tree
   class PropNode < Node
@@ -42,6 +42,16 @@ module Sass::Tree
     # @return [Fixnum]
     attr_accessor :tabs
 
+    # The source range in which the property name appears.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :name_source_range
+
+    # The source range in which the property value appears.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :value_source_range
+
     # @param name [Array<String, Sass::Script::Node>] See \{#name}
     # @param value [Sass::Script::Node] See \{#value}
     # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,

data/lib/sass/tree/root_node.rb

@@ -13,15 +13,31 @@ module Sass
         @template = template
       end
 
-      # Runs the dynamic Sass code *and* computes the CSS for the tree.
-      # @see #to_s
+      # Runs the dynamic Sass code and computes the CSS for the tree.
+      #
+      # @return [String] The compiled CSS.
       def render
+        css_tree.css
+      end
+
+      # Runs the dynamic Sass code and computes the CSS for the tree, along with
+      # the sourcemap.
+      #
+      # @return [(String, Sass::Source::Map)] The compiled CSS, as well as
+      #   the source map. @see #render
+      def render_with_sourcemap
+        css_tree.css_with_sourcemap
+      end
+
+      private
+
+      def css_tree
         Visitors::CheckNesting.visit(self)
         result = Visitors::Perform.visit(self)
         Visitors::CheckNesting.visit(result) # Check again to validate mixins
         result, extends = Visitors::Cssize.visit(result)
         Visitors::Extend.visit(result, extends)
-        result.to_s
+        result
       end
     end
   end

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

@@ -213,7 +213,9 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # or parses and includes the imported Sass file.
   def visit_import(node)
     if path = node.css_import?
-      return Sass::Tree::CssImportNode.resolved("url(#{path})")
+      resolved_node = Sass::Tree::CssImportNode.resolved("url(#{path})")
+      resolved_node.source_range = node.source_range
+      return resolved_node
     end
     file = node.imported_file
     handle_import_loop!(node) if @stack.any? {|e| e[:filename] == file.options[:filename]}
@@ -295,6 +297,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     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
     yield
   end
 
@@ -323,6 +326,11 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     var = @environment.var(node.name)
     return [] if node.guarded && var && !var.null?
     val = node.expr.perform(@environment)
+    if node.expr.source_range
+      val.source_range = node.expr.source_range
+    else
+      val.source_range = node.source_range
+    end
     @environment.set_var(node.name, val)
     []
   end

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

@@ -1,11 +1,25 @@
 # A visitor for converting a Sass tree into CSS.
 class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
-  protected
+  # The source mapping for the generated CSS file. This is only set if
+  # `build_source_mapping` is passed to the constructor and \{#render} has been
+  # run.
+  attr_reader :source_mapping
 
-  def initialize
+  # @param build_source_mapping [Boolean] Whether to build a
+  #   \{Sass::Source::Map} while creating the CSS output. The mapping will
+  #   be available from \{#source\_mapping} after the visitor has completed.
+  def initialize(build_source_mapping = false)
     @tabs = 0
+    @line = 1
+    @offset = 1
+    @result = ""
+    @source_mapping = Sass::Source::Map.new if build_source_mapping
   end
 
+  # Runs the visitor on `node`.
+  #
+  # @param node [Sass::Tree::Node] The root node of the tree to convert to CSS>
+  # @return [String] The CSS output.
   def visit(node)
     super
   rescue Sass::SyntaxError => e
@@ -13,6 +27,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     raise e
   end
 
+  protected
+
   def with_tabs(tabs)
     old_tabs, @tabs = @tabs, tabs
     yield
@@ -20,40 +36,116 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     @tabs = old_tabs
   end
 
+  # Associate all output produced in a block with a given node. Used for source
+  # mapping.
+  def for_node(node, attr_prefix = nil)
+    return yield unless @source_mapping
+    start_pos = Sass::Source::Position.new(@line, @offset)
+    yield
+
+    range_attr = attr_prefix ? :"#{attr_prefix}_source_range" : :source_range
+    return if node.invisible? || !node.send(range_attr)
+    source_range = node.send(range_attr)
+    target_end_pos = Sass::Source::Position.new(@line, @offset)
+    target_range = Sass::Source::Range.new(start_pos, target_end_pos, nil)
+    @source_mapping.add(source_range, target_range)
+  end
+
+  # Move the output cursor back `chars` characters.
+  def erase!(chars)
+    return if chars == 0
+    str = @result.slice!(-chars..-1)
+    newlines = str.count("\n")
+    if newlines > 0
+      @line -= newlines
+      @offset = @result[@result.rindex("\n") || 0..-1].size
+    else
+      @offset -= chars
+    end
+  end
+  
+  # Avoid allocating lots of new strings for `#output`. This is important
+  # because `#output` is called all the time.
+  NEWLINE = "\n"
+
+  # Add `s` to the output string and update the line and offset information
+  # accordingly.
+  def output(s)
+    if @lstrip
+      s = s.gsub(/\A\s+/, "")
+      @lstrip = false
+    end
+
+    newlines = s.count(NEWLINE)
+    if newlines > 0
+      @line += newlines
+      @offset = s[s.rindex(NEWLINE)..-1].size
+    else
+      @offset += s.size
+    end
+
+    @result << s
+  end
+
+  # Strip all trailing whitespace from the output string.
+  def rstrip!
+    erase! @result.length - 1 - (@result.rindex(/[^\s]/) || -1)
+  end
+
+  # lstrip the first output in the given block.
+  def lstrip
+    old_lstrip = @lstrip
+    @lstrip = true
+    yield
+  ensure
+    @lstrip = @lstrip && old_lstrip
+  end
+
+  # Prepend `prefix` to the output string.
+  def prepend!(prefix)
+    @result.insert 0, prefix
+    return unless @source_mapping
+
+    line_delta = prefix.count("\n")
+    offset_delta = prefix.gsub(/.*\n/, '').size
+    @source_mapping.shift_output_offsets(offset_delta)
+    @source_mapping.shift_output_lines(line_delta)
+  end
+
   def visit_root(node)
-    result = String.new
     node.children.each do |child|
       next if child.invisible?
-      child_str = visit(child)
-      result << child_str + (node.style == :compressed ? '' : "\n")
+      visit(child)
+      output "\n" unless node.style == :compressed
     end
-    result.rstrip!
-    return "" if result.empty?
-    result << "\n"
-    unless Sass::Util.ruby1_8? || result.ascii_only?
-      if node.children.first.is_a?(Sass::Tree::CharsetNode)
-        begin
-          encoding = node.children.first.name
-          # Default to big-endian encoding, because we have to decide somehow
-          encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
-          result = result.encode(Encoding.find(encoding))
-        rescue EncodingError
-        end
-      end
+    rstrip!
+    return "" if @result.empty?
+
+    output "\n"
+    return @result if Sass::Util.ruby1_8? || @result.ascii_only?
 
-      result = "@charset \"#{result.encoding.name}\";#{
-        node.style == :compressed ? '' : "\n"
-      }".encode(result.encoding) + result
+    if node.children.first.is_a?(Sass::Tree::CharsetNode)
+      begin
+        encoding = node.children.first.name
+        # Default to big-endian encoding, because we have to decide somehow
+        encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
+        @result = @result.encode(Encoding.find(encoding))
+      rescue EncodingError
+      end
     end
-    result
+
+    prepend! "@charset \"#{@result.encoding.name}\";#{
+      node.style == :compressed ? '' : "\n"
+    }".encode(@result.encoding)
+    @result
   rescue Sass::SyntaxError => e
     e.sass_template ||= node.template
     raise e
   end
 
   def visit_charset(node)
-    "@charset \"#{node.name}\";"
-  end 
+    for_node(node) {output("@charset \"#{node.name}\";")}
+  end
 
   def visit_comment(node)
     return if node.invisible?
@@ -62,55 +154,74 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     content = node.resolved_value.gsub(/^/, spaces)
     content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"} if node.type == :silent
     content.gsub!(/\n +(\* *(?!\/))?/, ' ') if (node.style == :compact || node.style == :compressed) && node.type != :loud
-    content
+    for_node(node) {output(content)}
   end
 
   def visit_directive(node)
     was_in_directive = @in_directive
     tab_str = '  ' * @tabs
-    return tab_str + node.resolved_value + ";" unless node.has_children
-    return tab_str + node.resolved_value + " {}" if node.children.empty?
+    if !node.has_children || node.children.empty?
+      output(tab_str)
+      for_node(node) {output(node.resolved_value)}
+      output(!node.has_children ? ";" : " {}")
+      return
+    end
+
     @in_directive = @in_directive || !node.is_a?(Sass::Tree::MediaNode)
-    result = if node.style == :compressed
-               "#{node.resolved_value}{"
-             else
-               "#{tab_str}#{node.resolved_value} {" + (node.style == :compact ? ' ' : "\n")
-             end
+    output(tab_str) if node.style != :compressed
+    for_node(node) {output(node.resolved_value)}
+    output(node.style == :compressed ? "{" : " {")
+    output(node.style == :compact ? ' ' : "\n") if node.style != :compressed
+
     was_prop = false
     first = true
     node.children.each do |child|
       next if child.invisible?
       if node.style == :compact
         if child.is_a?(Sass::Tree::PropNode)
-          with_tabs(first || was_prop ? 0 : @tabs + 1) {result << visit(child) << ' '}
+          with_tabs(first || was_prop ? 0 : @tabs + 1) do
+            visit(child)
+            output(' ')
+          end
         else
-          result[-1] = "\n" if was_prop
-          rendered = with_tabs(@tabs + 1) {visit(child).dup}
-          rendered = rendered.lstrip if first
-          result << rendered.rstrip + "\n"
+          if was_prop
+            erase! 1
+            output "\n"
+          end
+
+          if first
+            lstrip {with_tabs(@tabs + 1) {visit(child)}}
+          else
+            with_tabs(@tabs + 1) {visit(child)}
+          end
+
+          rstrip!
+          output "\n"
         end
         was_prop = child.is_a?(Sass::Tree::PropNode)
         first = false
       elsif node.style == :compressed
-        result << (was_prop ? ";" : "") << with_tabs(0) {visit(child)}
+        output(was_prop ? ";" : "")
+        with_tabs(0) {visit(child)}
         was_prop = child.is_a?(Sass::Tree::PropNode)
       else
-        result << with_tabs(@tabs + 1) {visit(child)} + "\n"
+        with_tabs(@tabs + 1) {visit(child)}
+        output "\n"
       end
     end
-    result.rstrip + if node.style == :compressed
-                      "}"
-                    else
-                      (node.style == :expanded ? "\n" : " ") + "}\n"
-                    end
+    rstrip!
+    output(if node.style == :compressed
+             "}"
+           else
+             (node.style == :expanded ? "\n" : " ") + "}\n"
+           end)
   ensure
     @in_directive = was_in_directive
   end
 
   def visit_media(node)
-    str = with_tabs(@tabs + node.tabs) {visit_directive(node)}
-    str.gsub!(/\n\Z/, '') unless node.style == :compressed || node.group_end
-    str
+    with_tabs(@tabs + node.tabs) {visit_directive(node)}
+    erase! 1 unless node.style == :compressed || node.group_end || @result[-1] != ?\n
   end
 
   def visit_supports(node)
@@ -124,10 +235,15 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   def visit_prop(node)
     return if node.resolved_value.empty?
     tab_str = '  ' * (@tabs + node.tabs)
+    output(tab_str)
+    for_node(node, :name) {output(node.resolved_name)}
     if node.style == :compressed
-      "#{tab_str}#{node.resolved_name}:#{node.resolved_value}"
+      output(":");
+      for_node(node, :value) {output(node.resolved_value)}
     else
-      "#{tab_str}#{node.resolved_name}: #{node.resolved_value};"
+      output(": ")
+      for_node(node, :value) {output(node.resolved_value)}
+      output(";")
     end
   end
 
@@ -158,18 +274,18 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       joined_rules.gsub!(/\s*\n\s*/, "#{line_separator}#{per_rule_indent}")
       total_rule = total_indent << joined_rules
 
-      to_return = ''
       old_spaces = '  ' * @tabs
       spaces = '  ' * (@tabs + 1)
       if node.style != :compressed
         if node.options[:debug_info] && !@in_directive
-          to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
+          visit(debug_info_rule(node.debug_info, node.options))
+          output "\n"
         elsif node.options[:trace_selectors]
-          to_return << "#{old_spaces}/* "
-          to_return << node.stack_trace.join("\n   #{old_spaces}")
-          to_return << " */\n"
+          output("#{old_spaces}/* ")
+          output(node.stack_trace.join("\n   #{old_spaces}"))
+          output(" */\n")
         elsif node.options[:line_comments]
-          to_return << "#{old_spaces}/* line #{node.line}"
+          output("#{old_spaces}/* line #{node.line}")
 
           if node.filename
             relative_filename = if node.options[:css_filename]
@@ -181,26 +297,37 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
               end
             end
             relative_filename ||= node.filename
-            to_return << ", #{relative_filename}"
+            output(", #{relative_filename}")
           end
 
-          to_return << " */\n"
+          output(" */\n")
         end
       end
 
+      end_props, trailer, tabs  = '', '', 0
       if node.style == :compact
-        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(' ')}
-        to_return << "#{total_rule} { #{properties} }#{"\n" if node.group_end}"
+        separator, end_props, bracket = ' ', ' ', ' { '
+        trailer = "\n" if node.group_end
       elsif node.style == :compressed
-        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(';')}
-        to_return << "#{total_rule}{#{properties}}"
+        separator, bracket = ';', '{'
       else
-        properties = with_tabs(@tabs + 1) {node.children.map {|a| visit(a)}.join("\n")}
+        tabs = @tabs + 1
+        separator, bracket = "\n", " {\n"
+        trailer = "\n" if node.group_end
         end_props = (node.style == :expanded ? "\n" + old_spaces : ' ')
-        to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if node.group_end}"
+      end
+      output(total_rule)
+      output(bracket)
+
+      with_tabs(tabs) do
+        node.children.each_with_index do |child, i|
+          output(separator) if i > 0
+          visit(child)
+        end
       end
 
-      to_return
+      output(end_props)
+      output("}" + trailer)
     end
   end