class Sass::Tree::RuleNode

def ==(other)
  self.class == other.class && rule == other.rule && super
end

def _cssize(extends, parent)
  node = super
  rules = node.children.select {|c| c.is_a?(RuleNode)}
  props = node.children.reject {|c| c.is_a?(RuleNode) || c.invisible?}
  unless props.empty?
    node.children = props
    rules.each {|r| r.tabs += 1} if style == :nested
    rules.unshift(node)
  end
  rules.last.group_end = true unless parent || rules.empty?
  rules
end

def _to_s(tabs)
  tabs = tabs + self.tabs
  rule_separator = style == :compressed ? ',' : ', '
  line_separator =
    case style
      when :nested, :expanded; "\n"
      when :compressed; ""
      else; " "
    end
  rule_indent = '  ' * (tabs - 1)
  per_rule_indent, total_indent = [:nested, :expanded].include?(style) ? [rule_indent, ''] : ['', rule_indent]
  total_rule = total_indent + resolved_rules.members.
    map {|seq| seq.to_a.join}.
    join(rule_separator).split("\n").map do |line|
    per_rule_indent + line.strip
  end.join(line_separator)
  to_return = ''
  old_spaces = '  ' * (tabs - 1)
  spaces = '  ' * tabs
  if style != :compressed
    if @options[:debug_info]
      to_return << debug_info_rule.to_s(tabs) << "\n"
    elsif @options[:line_comments]
      to_return << "#{old_spaces}/* line #{line}"
      if filename
        relative_filename = if @options[:css_filename]
          begin
            Pathname.new(filename).relative_path_from(
              Pathname.new(File.dirname(@options[:css_filename]))).to_s
          rescue ArgumentError
            nil
          end
        end
        relative_filename ||= filename
        to_return << ", #{relative_filename}"
      end
      to_return << " */\n"
    end
  end
  if style == :compact
    properties = children.map { |a| a.to_s(1) }.join(' ')
    to_return << "#{total_rule} { #{properties} }#{"\n" if group_end}"
  elsif style == :compressed
    properties = children.map { |a| a.to_s(1) }.join(';')
    to_return << "#{total_rule}{#{properties}}"
  else
    properties = children.map { |a| a.to_s(tabs + 1) }.join("\n")
    end_props = (style == :expanded ? "\n" + old_spaces : ' ')
    to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if group_end}"
  end
  to_return
end

def add_rules(node)
  @rule = Haml::Util.strip_string_array(
    Haml::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
end

def continued?
  last = @rule.last
  last.is_a?(String) && last[-1] == ?,
end

def cssize!(extends, parent)
  self.resolved_rules = @parsed_rules.resolve_parent_refs(parent && parent.resolved_rules)
  super
end

def debug_info
  {:filename => filename && ("file://" + URI.escape(File.expand_path(filename))),
   :line => self.line}
end

def debug_info_rule
  node = DirectiveNode.new("@media -sass-debug-info")
  debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
    rule = 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)])
          ])
      ])
    prop = PropNode.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 do_extend(extends)
  node = dup
  node.resolved_rules = resolved_rules.do_extend(extends)
  node
end

def initialize(rule)
  #p rule
  merged = Haml::Util.merge_adjacent_strings(rule)
  #p merged
  @rule = Haml::Util.strip_string_array(merged)
  #p @rule
  @tabs = 0
  super()
end

def invalid_child?(child)
  super unless child.is_a?(ExtendNode)
end

def perform!(environment)
  @parsed_rules = Sass::SCSS::StaticParser.new(run_interp(@rule, environment), self.line).
    parse_selector(self.filename)
  super
end

def to_sass(tabs, opts = {})
  name = selector_to_sass(rule, opts)
  name = "\\" + name if name[0] == ?:
  name.gsub(/^/, '  ' * tabs) + children_to_src(tabs, opts, :sass)
end

def to_scss(tabs, opts = {})
  name = selector_to_scss(rule, tabs, opts)
  res = name + children_to_src(tabs, opts, :scss)
  if children.last.is_a?(CommentNode) && children.last.silent
    res.slice!(-3..-1)
    res << "\n" << ('  ' * tabs) << "}\n"
  end
  res
end