class Sass::Tree::Node

def <<(child)
  return if child.nil?
  check_child! child
  self.has_children = true
  @children << child
end

def ==(other)
  self.class == other.class && other.children == children
end

def _cssize(extends, parent)
  node = dup
  node.cssize!(extends, parent)
  node
end

def _perform(environment)
  node = dup
  node.perform!(environment)
  node
end

def _to_s
  raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #_to_s or #to_s.")
end

def balance(*args)
  res = Haml::Shared.balance(*args)
  return res if res
  raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
end

def check_child!(child)
  if msg = invalid_child?(child)
    raise Sass::SyntaxError.new(msg, :line => child.line)
  end
end

def children=(children)
  self.has_children ||= !children.empty?
  @children = children
end

def children_to_src(tabs, opts, fmt)
  return fmt == :sass ? "\n" : " {}\n" if children.empty?
  (fmt == :sass ? "\n" : " {\n") +
    children.map {|c| c.send("to_#{fmt}", tabs + 1, opts)}.join.rstrip +
    (fmt == :sass ? "\n" : " }\n")
end

def cssize(extends, parent = nil)
  _cssize(extends, (parent if parent.class == self.class))
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => filename, :line => line)
  raise e
end

def cssize!(extends, parent)
  self.children = children.map {|c| c.cssize(extends, self)}.flatten
end

def dasherize(s, opts)
  if opts[:dasherize]
    s.gsub('_', '-')
  else
    s
  end
end

def do_extend(extends)
  node = dup
  node.children = children.map {|c| c.do_extend(extends)}
  node
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => filename, :line => line)
  raise e
end

def each(&block)
  yield self
  children.each {|c| c.each(&block)}
end

def filename
  @filename || (@options && @options[:filename])
end

def initialize
  @children = []
end

def invalid_child?(child)
  case child
  when Tree::MixinDefNode
    "Mixins may only be defined at the root of a document."
  when Tree::ImportNode
    "Import directives may only be used at the root of a document."
  when Tree::ExtendNode
    "Extend directives may only be used within rules."
  end
end

def invisible?; false; end

def options=(options)
  children.each {|c| c.options = options}
  @options = options
end

def perform(environment)
  _perform(environment)
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => filename, :line => line)
  raise e
end

def perform!(environment)
  self.children = perform_children(Environment.new(environment))
end

def perform_children(environment)
  children.map {|c| c.perform(environment)}.flatten
end

def run_interp(text, environment)
  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.strip
end

def selector_to_sass(sel, opts)
  sel.map do |r|
    if r.is_a?(String)
      r.gsub(/(,[ \t]*)?\n\s*/) {$1 ? $1 + "\n" : " "}
    else
      "\#{#{r.to_sass(opts)}}"
    end
  end.join
end

def selector_to_scss(sel, tabs, opts)
  sel.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(opts)}}"}.
    join.gsub(/^[ \t]*/, '  ' * tabs)
end

def selector_to_src(sel, tabs, opts, fmt)
  fmt == :sass ? selector_to_sass(sel, opts) : selector_to_scss(sel, tabs, opts)
end

def semi(fmt)
  fmt == :sass ? "" : ";"
end

def style
  @options[:style]
end

def to_s(*args)
  _to_s(*args)
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => filename, :line => line)
  raise e
end

def to_sass(tabs = 0, opts = {})
  to_src(tabs, opts, :sass)
end

def to_scss(tabs = 0, opts = {})
  to_src(tabs, opts, :scss)
end

def to_src(tabs, opts, fmt)
  raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #to_#{fmt}.")
end