class Sass::Tree::Visitors::ToCss

A visitor for converting a Sass tree into CSS.

def debug_info_rule(debug_info, options)

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|
    rule = Sass::Tree::RuleNode.new([""])
    rule.resolved_rules = Sass::Selector::CommaSequence.new(
      [Sass::Selector::Sequence.new(
          [Sass::Selector::SimpleSequence.new(
              [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)],
              false)
          ])
      ])
    prop = Sass::Tree::PropNode.new([""], Sass::Script::Value::String.new(''), :new)
    prop.resolved_name = "font-family"
    prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
    rule << prop
    node << rule
  end
  node.options = options.merge(:debug_info => false,
                               :line_comments => false,
                               :style => :compressed)
  node
end

def erase!(chars)

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

def for_node(node, attr_prefix = nil)

mapping.
Associate all output produced in a block with a given node. Used for source

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

def initialize(build_source_mapping = false)

Parameters:

build_source_mapping (Boolean) -- Whether to build a

def initialize(build_source_mapping = false)
  @tabs = 0
  @line = 1
  @offset = 1
  @result = ""
  @source_mapping = Sass::Source::Map.new if build_source_mapping
end

def lstrip

lstrip the first output in the given block.

def lstrip
  old_lstrip = @lstrip
  @lstrip = true
  yield
ensure
  @lstrip = @lstrip && old_lstrip
end

def output(s)

accordingly.
Add `s` to the output string and update the line and offset information

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

def prepend!(prefix)

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 rstrip!

Strip all trailing whitespace from the output string.

def rstrip!
  erase! @result.length - 1 - (@result.rindex(/[^\s]/) || -1)
end

def visit(node)

Returns:

(String) - The CSS output.

Parameters:

node (Sass::Tree::Node) -- The root node of the tree to convert to CSS>

def visit(node)
  super
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => node.filename, :line => node.line)
  raise e
end

def visit_charset(node)

def visit_charset(node)
  for_node(node) {output("@charset \"#{node.name}\";")}
end

def visit_comment(node)

def visit_comment(node)
  return if node.invisible?
  spaces = ('  ' * [@tabs - node.resolved_value[/^ */].size, 0].max)
  content = node.resolved_value.gsub(/^/, spaces)
  if node.type == :silent
    content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"}
  end
  if (node.style == :compact || node.style == :compressed) && node.type != :loud
    content.gsub!(/\n +(\* *(?!\/))?/, ' ')
  end
  for_node(node) {output(content)}
end

def visit_cssimport(node)

def visit_cssimport(node)
  visit_directive(node)
end

def visit_directive(node)

rubocop:disable MethodLength
@comment

def visit_directive(node)
  was_in_directive = @in_directive
  tab_str = '  ' * @tabs
  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)
  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) do
          visit(child)
          output(' ')
        end
      else
        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
      output(was_prop ? ";" : "")
      with_tabs(0) {visit(child)}
      was_prop = child.is_a?(Sass::Tree::PropNode)
    else
      with_tabs(@tabs + 1) {visit(child)}
      output "\n"
    end
  end
  rstrip!
  if node.style == :expanded
    output("\n#{tab_str}")
  elsif node.style != :compressed
    output(" ")
  end
  output("}")
ensure
  @in_directive = was_in_directive
end

def visit_keyframerule(node)

def visit_keyframerule(node)
  visit_directive(node)
end

def visit_media(node)

def visit_media(node)
  with_tabs(@tabs + node.tabs) {visit_directive(node)}
  output("\n") if node.style != :compressed && node.group_end
end

def visit_prop(node)

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
    output(":")
    for_node(node, :value) {output(node.resolved_value)}
  else
    output(": ")
    for_node(node, :value) {output(node.resolved_value)}
    output(";")
  end
end

def visit_root(node)

def visit_root(node)
  node.children.each do |child|
    next if child.invisible?
    visit(child)
    unless node.style == :compressed
      output "\n"
      if child.is_a?(Sass::Tree::DirectiveNode) && child.has_children && !child.bubbles?
        output "\n"
      end
    end
  end
  rstrip!
  return "" if @result.empty?
  output "\n"
  unless Sass::Util.ruby1_8? || @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
      # methods as per http://encoding.spec.whatwg.org/#decode-and-encode.
      prepend! "\uFEFF"
    else
      prepend! "@charset \"UTF-8\";\n"
    end
  end
  @result
rescue Sass::SyntaxError => e
  e.sass_template ||= node.template
  raise e
end

def visit_rule(node)