haml 2.2.24 → 3.0.0.beta.1

data/lib/sass/tree/prop_node.rb

@@ -3,24 +3,54 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class PropNode < Node
-    # The name of the property.
+    # The name of the property,
+    # interspersed with {Sass::Script::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
     #
-    # @return [String]
+    # @return [Array<String, Sass::Script::Node>]
     attr_accessor :name
 
-    # The value of the property,
-    # either a plain string or a SassScript parse tree.
+    # The name of the property
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Node#perform} has been called.
+    #
+    # @return [String]
+    attr_accessor :resolved_name
+
+    # The value of the property.
     #
-    # @return [String, Script::Node]
+    # @return [Sass::Script::Node]
     attr_accessor :value
 
-    # @param name [String] See \{#name}
-    # @param value [String] See \{#value}
+    # The value of the property
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Node#perform} has been called.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # How deep this property is indented
+    # relative to a normal property.
+    # This is only greater than 0 in the case that:
+    #
+    # * This node is in a CSS tree
+    # * The style is :nested
+    # * This is a child property of another property
+    # * The parent property has a value, and thus will be rendered
+    #
+    # @return [Fixnum]
+    attr_accessor :tabs
+
+    # @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,
     #   `:old` if it uses `:a b`-style syntax
     def initialize(name, value, prop_syntax)
-      @name = name
+      @name = Haml::Util.strip_string_array(
+        Haml::Util.merge_adjacent_strings(name))
       @value = value
+      @tabs = 0
       @prop_syntax = prop_syntax
       super()
     end
@@ -34,69 +64,79 @@ module Sass::Tree
       self.class == other.class && name == other.name && value == other.value && super
     end
 
-    # Computes the CSS for the property.
-    #
-    # @param tabs [Fixnum] The level of indentation for the CSS
-    # @param parent_name [String] The name of the parent property (e.g. `text`) or nil
-    # @return [String] The resulting CSS
-    # @raise [Sass::SyntaxError] if the property uses invalid syntax
-    def to_s(tabs, parent_name = nil)
-      if @options[:property_syntax] == :old && @prop_syntax == :new
-        raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.", @line)
-      elsif @options[:property_syntax] == :new && @prop_syntax == :old
-        raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.", @line)
-      end
-
-      if value[-1] == ?;
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).", @line)
-      end
-      real_name = name
-      real_name = "#{parent_name}-#{real_name}" if parent_name
-      
-      if value.empty? && children.empty?
-        message = "Invalid property: #{declaration.dump} (no value)." +
-          pseudo_class_selector_message
-        raise Sass::SyntaxError.new(message, @line)
-      end
-      
-      join_string = case style
-                    when :compact; ' '
-                    when :compressed; ''
-                    else "\n"
-                    end
-      spaces = '  ' * (tabs - 1)
-      to_return = ''
-      if !value.empty?
-        to_return << "#{spaces}#{real_name}:#{style == :compressed ? '' : ' '}#{value};#{join_string}"
-      end
-      
-      children.each do |kid|
-        next if kid.invisible?
-        to_return << kid.to_s(tabs, real_name) << join_string
-      end
-      
-      (style == :compressed && parent_name) ? to_return : to_return[0...-1]
-    end
-
     # Returns a appropriate message indicating how to escape pseudo-class selectors.
     # This only applies for old-style properties with no value,
     # so returns the empty string if this is new-style.
     #
+    # This should only be called once \{#perform} has been called.
+    #
     # @return [String] The message
     def pseudo_class_selector_message
-      return "" if @prop_syntax == :new || !value.empty?
+      return "" if @prop_syntax == :new || !resolved_value.empty?
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
     protected
 
-    # Runs any SassScript that may be embedded in the property.
+    def to_src(tabs, opts, fmt)
+      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass}}"}.join
+      old = opts[:old] && fmt == :sass
+      initial = old ? ':' : ''
+      mid = old ? '' : ':'
+      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value)}"
+      return res + "#{semi fmt}\n" if children.empty?
+      res.rstrip + children_to_src(tabs, opts, fmt)
+    end
+
+    # Computes the CSS for the property.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @return [String] The resulting CSS
+    def _to_s(tabs)
+      to_return = '  ' * (tabs - 1 + self.tabs) + resolved_name + ":" +
+        (style == :compressed ? '' : ' ') + resolved_value + (style == :compressed ? "" : ";")
+    end
+
+    # Converts nested properties into flat properties.
+    #
+    # @param parent [PropNode, nil] The parent node of this node,
+    #   or nil if the parent isn't a {PropNode}
+    # @raise [Sass::SyntaxError] if the property uses invalid syntax
+    def _cssize(parent)
+      node = super
+      result = node.children.dup
+      if !node.resolved_value.empty? || node.children.empty?
+        node.send(:check!)
+        result.unshift(node)
+      end
+      result
+    end
+
+    # Updates the name and indentation of this node based on the parent name
+    # and nesting level.
+    #
+    # @param parent [PropNode, nil] The parent node of this node,
+    #   or nil if the parent isn't a {PropNode}
+    def cssize!(parent)
+      self.resolved_name = "#{parent.resolved_name}-#{resolved_name}" if parent
+      self.tabs = parent.tabs + (parent.resolved_value.empty? ? 0 : 1) if parent && style == :nested
+      super
+    end
+
+    # Runs any SassScript that may be embedded in the property,
+    # and invludes the parent property, if any.
     #
     # @param environment [Sass::Environment] The lexical environment containing
     #   variable and mixin values
     def perform!(environment)
-      @name = interpolate(@name, environment)
-      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
+      @resolved_name = run_interp(@name, environment)
+      val = @value.perform(environment)
+      @resolved_value =
+        if @value.context == :equals && val.is_a?(Sass::Script::String)
+          val.value
+        else
+          val.to_s
+        end
       super
     end
 
@@ -114,8 +154,63 @@ module Sass::Tree
 
     private
 
+    def check!
+      if @options[:property_syntax] == :old && @prop_syntax == :new
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.")
+      elsif @options[:property_syntax] == :new && @prop_syntax == :old
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.")
+      elsif resolved_value.empty?
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value)." +
+          pseudo_class_selector_message)
+      end
+    end
+
     def declaration
-      (@prop_syntax == :new ? "#{name}: #{value}" : ":#{name} #{value}").strip
+      if @prop_syntax == :new
+        "#{resolved_name}: #{resolved_value}"
+      else
+        ":#{resolved_name} #{resolved_value}"
+      end.strip
+    end
+
+    class << self
+      # @private
+      def val_to_sass(value)
+        return value.to_sass unless value.context == :equals
+        val_to_sass_comma(value).to_sass
+      end
+
+      private
+
+      def val_to_sass_comma(node)
+        return node unless node.is_a?(Sass::Script::Operation)
+        return val_to_sass_concat(node) unless node.operator == :comma
+
+        Sass::Script::Operation.new(
+          val_to_sass_concat(node.operand1),
+          val_to_sass_comma(node.operand2),
+          node.operator)
+      end
+
+      def val_to_sass_concat(node)
+        return node unless node.is_a?(Sass::Script::Operation)
+        return val_to_sass_div(node) unless node.operator == :concat
+
+        Sass::Script::Operation.new(
+          val_to_sass_div(node.operand1),
+          val_to_sass_concat(node.operand2),
+          node.operator)
+      end
+
+      def val_to_sass_div(node)
+        unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
+            node.operand1.is_a?(Sass::Script::Number) &&
+            node.operand2.is_a?(Sass::Script::Number)
+          return node
+        end
+
+        Sass::Script::String.new("(#{node.to_sass})")
+      end
     end
   end
 end

data/lib/sass/tree/root_node.rb

@@ -0,0 +1,118 @@
+module Sass
+  module Tree
+    # A static node that is the root node of the Sass document.
+    class RootNode < Node
+      # The Sass template from which this node was created
+      #
+      # @param template [String]
+      attr_reader :template
+
+      # @param template [String] The Sass template from which this node was created
+      def initialize(template)
+        super()
+        @template = template
+      end
+
+      # @see Node#to_s
+      def to_s(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      # @see Node#perform
+      def perform(environment)
+        environment.options = @options if environment.options.nil? || environment.options.empty?
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      # @see Node#cssize
+      def cssize(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      # @see \{Node#perform!}
+      def perform!(environment)
+        environment.options = @options if environment.options.nil? || environment.options.empty?
+        super
+      end
+
+      # Converts a node to Sass code that will generate it.
+      #
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The Sass code corresponding to the node
+      def to_sass(opts = {})
+        to_src(opts, :sass)
+      end
+
+      # Converts a node to SCSS code that will generate it.
+      #
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The SCSS code corresponding to the node
+      def to_scss(opts = {})
+        to_src(opts, :scss)
+      end
+
+      protected
+
+      def to_src(opts, fmt)
+        Haml::Util.enum_cons(children + [nil], 2).map do |child, nxt|
+          child.send("to_#{fmt}", 0, opts) +
+            if nxt &&
+                (child.is_a?(CommentNode) && child.line + child.value.count("\n") + 1 == nxt.line) ||
+                (child.is_a?(ImportNode) && nxt.is_a?(ImportNode) && child.line + 1 == nxt.line)
+              ""
+            else
+              "\n"
+            end
+        end.join.rstrip + "\n"
+      end
+
+      # Destructively converts this static Sass node into a static CSS node,
+      # and checks that there are no properties at root level.
+      #
+      # @param parent [Node, nil] The parent node of this node.
+      #   This should only be non-nil if the parent is the same class as this node
+      # @see Node#cssize!
+      def cssize!(parent)
+        super
+        return unless child = children.find {|c| c.is_a?(PropNode)}
+        message = "Properties aren't allowed at the root of a document." +
+          child.pseudo_class_selector_message
+        raise Sass::SyntaxError.new(message, :line => child.line)
+      end
+
+      # Computes the CSS corresponding to this Sass tree.
+      #
+      # @param args [Array] ignored
+      # @return [String] The resulting CSS
+      # @see Sass::Tree
+      def _to_s(*args)
+        result = String.new
+        children.each do |child|
+          next if child.invisible?
+          child_str = child.to_s(1)
+          result << child_str + (style == :compressed ? '' : "\n")
+        end
+        result.rstrip!
+        return "" if result.empty?
+        return result + "\n"
+      end
+
+      # Returns false, because all nodes are allowed at the root of the document
+      # (properties are detected elsewhere post-mixin-resolution).
+      #
+      # @see Node#invalid_child?
+      def invalid_child?(child)
+        false
+      end
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -1,4 +1,5 @@
 require 'pathname'
+require 'uri'
 
 module Sass::Tree
   # A static node reprenting a CSS rule.
@@ -9,30 +10,23 @@ module Sass::Tree
     # @private
     PARENT = '&'
 
-    # The CSS selectors for this rule.
-    # Each string is a selector line, and the lines are meant to be separated by commas.
-    # For example,
-    #
-    #     foo, bar, baz,
-    #     bip, bop, bup
-    #
-    # would be
-    #
-    #     ["foo, bar, baz",
-    #      "bip, bop, bup"]
+    # The CSS selector for this rule,
+    # interspersed with {Sass::Script::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
     #
-    # @return [Array<String>]
-    attr_accessor :rules
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :rule
 
     # The CSS selectors for this rule,
     # parsed for commas and parent-references.
     # It's only set once {Tree::Node#perform} has been called.
     #
-    # It's an array of arrays of arrays.
-    # The first level of arrays represents distinct lines in the Sass file;
-    # the second level represents comma-separated selectors;
-    # the third represents structure within those selectors,
+    # It's an array of arrays.
+    # The first level of arrays comma-separated selectors;
+    # the second represents structure within those selectors,
     # currently only parent-refs (represented by `:parent`).
+    # Newlines are represented as literal `\n` characters in the strings.
     # For example,
     #
     #     &.foo, bar, baz,
@@ -40,15 +34,54 @@ module Sass::Tree
     #
     # would be
     #
-    #     [[[:parent, "foo"], ["bar"], ["baz"]],
-    #      [["bip"], [:parent, "bop"], ["bup"]]]
+    #     [[:parent, ".foo"], ["bar"], ["baz"],
+    #      ["\nbip"], [:parent, ".bop"], ["bup"]]
     #
-    # @return [Array<Array<Array<String|Symbol>>>]
+    # @return [Array<Array<String, Symbol>>]
     attr_accessor :parsed_rules
 
-    # @param rule [String] The first CSS rule. See \{#rules}
+    # The CSS selectors for this rule,
+    # with all nesting and parent references resolved.
+    # It's only set once {Tree::Node#cssize} has been called.
+    #
+    # Each element is a distinct selector, separated by commas.
+    # Newlines are represented as literal `\n` characters in the strings.
+    # For example,
+    #
+    #     foo bar, baz,
+    #     bang, bip bop, blip
+    #
+    # would be
+    #
+    #     ["foo bar", "baz", "\nbang", "bip bop", "blip"]
+    #
+    # @return [Array<String>]
+    attr_accessor :resolved_rules
+
+    # How deep this rule is indented
+    # relative to a base-level rule.
+    # This is only greater than 0 in the case that:
+    #
+    # * This node is in a CSS tree
+    # * The style is :nested
+    # * This is a child rule of another rule
+    # * The parent rule has properties, and thus will be rendered
+    #
+    # @return [Fixnum]
+    attr_accessor :tabs
+
+    # Whether or not this rule is the last rule in a nested group.
+    # This is only set in a CSS tree.
+    #
+    # @return [Boolean]
+    attr_accessor :group_end
+
+    # @param rule [Array<String, Sass::Script::Node>]
+    #   The CSS rule. See \{#rule}
     def initialize(rule)
-      @rules = [rule]
+      @rule = Haml::Util.strip_string_array(
+        Haml::Util.merge_adjacent_strings(rule))
+      @tabs = 0
       super()
     end
 
@@ -58,63 +91,86 @@ module Sass::Tree
     # @return [Boolean] Whether or not this node and the other object
     #   are the same
     def ==(other)
-      self.class == other.class && rules == other.rules && super
+      self.class == other.class && rule == other.rule && super
     end
 
     # Adds another {RuleNode}'s rules to this one's.
     #
     # @param node [RuleNode] The other node
     def add_rules(node)
-      @rules += node.rules
+      @rule = Haml::Util.strip_string_array(
+        Haml::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
     end
 
     # @return [Boolean] Whether or not this rule is continued on the next line
     def continued?
-      @rules.last[-1] == ?,
+      last = @rule.last
+      last.is_a?(String) && last[-1] == ?,
     end
 
+    # @see Node#to_sass
+    def to_sass(tabs, opts = {})
+      name = rule.map do |r|
+        if r.is_a?(String)
+          r.gsub(/(,[ \t]*)?\n\s*/) {$1 ? $1 + "\n" : " "}
+        else
+          "\#{#{r.to_sass}}"
+        end
+      end.join
+      name = "\\" + name if name[0] == ?:
+      name.gsub(/^/, '  ' * tabs) + children_to_src(tabs, opts, :sass)
+    end
+
+    def to_scss(tabs, opts = {})
+      name = rule.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass}}"}.
+        join.gsub(/^[ \t]*/, '  ' * tabs)
+
+      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
+
+    protected
+
     # Computes the CSS for the rule.
     #
     # @param tabs [Fixnum] The level of indentation for the CSS
-    # @param super_rules [Array<Array<String>>] The rules for the parent node
-    #   (see \{#rules}), or `nil` if there are no parents
     # @return [String] The resulting CSS
-    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
-    def to_s(tabs, super_rules = nil)
-      resolved_rules = resolve_parent_refs(super_rules)
-
-      properties = []
-      sub_rules = []
+    def _to_s(tabs)
+      tabs = tabs + self.tabs
 
       rule_separator = style == :compressed ? ',' : ', '
-      line_separator = [:nested, :expanded].include?(style) ? ",\n" : rule_separator
+      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.map do |line|
-        per_rule_indent + line.join(rule_separator)
+      total_rule = total_indent + resolved_rules.join(rule_separator).split("\n").map do |line|
+        per_rule_indent + line.strip
       end.join(line_separator)
 
-      children.each do |child|
-        next if child.invisible?
-        if child.is_a? RuleNode
-          sub_rules << child
-        else
-          properties << child
-        end
-      end
-
       to_return = ''
-      if !properties.empty?
-        old_spaces = '  ' * (tabs - 1)
-        spaces = '  ' * tabs
-        if @options[:line_comments] && style != :compressed
+      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(filename).relative_path_from(
                   Pathname.new(File.dirname(@options[:css_filename]))).to_s
               rescue ArgumentError
                 nil
@@ -126,70 +182,101 @@ module Sass::Tree
 
           to_return << " */\n"
         end
-
-        if style == :compact
-          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
-          to_return << "#{total_rule} { #{properties} }\n"
-        elsif style == :compressed
-          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
-          to_return << "#{total_rule}{#{properties}}"
-        else
-          properties = properties.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
-          end_props = (style == :expanded ? "\n" + old_spaces : ' ')
-          to_return << "#{total_rule} {\n#{properties}#{end_props}}\n"
-        end
       end
 
-      tabs += 1 unless properties.empty? || style != :nested
-      sub_rules.each do |sub|
-        to_return << sub.to_s(tabs, resolved_rules)
+      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
 
-    protected
-
     # Runs any SassScript that may be embedded in the rule,
     # and parses the selectors for commas.
     #
     # @param environment [Sass::Environment] The lexical environment containing
     #   variable and mixin values
     def perform!(environment)
-      @parsed_rules = @rules.map {|r| parse_selector(interpolate(r, environment))}
+      @parsed_rules = parse_selector(run_interp(@rule, environment))
+      super
+    end
+
+    # Converts nested rules into a flat list of rules.
+    #
+    # @param parent [RuleNode, nil] The parent node of this node,
+    #   or nil if the parent isn't a {RuleNode}
+    def _cssize(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
+
+    # Resolves parent references and nested selectors,
+    # and updates the indentation based on the parent's indentation.
+    #
+    # @param parent [RuleNode, nil] The parent node of this node,
+    #   or nil if the parent isn't a {RuleNode}
+    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
+    def cssize!(parent)
+      self.resolved_rules = resolve_parent_refs(parent && parent.resolved_rules)
       super
     end
 
+    # A hash that will be associated with this rule in the CSS document
+    # if the {file:SASS_REFERENCE.md#debug_info-option `:debug_info` option} is enabled.
+    # This data is used by e.g. [the FireSass Firebug extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
+    #
+    # @return [{#to_s => #to_s}]
+    def debug_info
+      {:filename => filename && ("file://" + URI.escape(File.expand_path(filename))),
+       :line => self.line}
+    end
+
     private
 
     def resolve_parent_refs(super_rules)
       if super_rules.nil?
-        return @parsed_rules.map do |line|
-          line.map do |rule|
-            if rule.include?(:parent)
-              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", self.line)
-            end
+        return @parsed_rules.map do |rule|
+          if rule.include?(:parent)
+            raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.")
+          end
 
-            rule.join
-          end.compact
+          rule.join
         end
       end
 
       new_rules = []
-      super_rules.each do |super_line|
-        @parsed_rules.each do |line|
+      super_rules.each do |super_rule|
+        @parsed_rules.each do |rule|
           new_rules << []
 
-          super_line.each do |super_rule|
-            line.each do |rule|
-              rule = [:parent, " ", *rule] unless rule.include?(:parent)
+          # An initial newline of the child rule
+          # should be moved to the beginning of the entire rule
+          rule.first.slice!(0) if nl = (rule.first.is_a?(String) && rule.first[0] == ?\n)
+          rule = [nl ? "\n" : "", :parent, " ", *rule] unless rule.include?(:parent)
 
-              new_rules.last << rule.map do |segment|
-                next segment unless segment == :parent
-                super_rule
-              end.join
-            end
-          end
+          new_rules.last << rule.map do |segment|
+            next segment unless segment == :parent
+            super_rule
+          end.join
         end
       end
       new_rules
@@ -202,18 +289,13 @@ module Sass::Tree
       while scanner.rest?
         rules.last << scanner.scan(/[^",&]*/)
         case scanner.scan(/./)
-        when '&'
-          warn <<END unless rules.last.empty? || rules.last.last =~ /(^|\s)$/
-DEPRECATION WARNING:
-On line #{@line}#{" of '#{@filename}'" if @filename}
-In Sass 3, parent selectors will only be able to appear
-at the beginning of simple selector sequences.
-For example, ".foo &.bar" is allowed but ".bar&" is not.
-END
-          rules.last << :parent
+        when '&'; rules.last << :parent
         when ','
           scanner.scan(/\s*/)
-          rules << [] if scanner.rest?
+          if scanner.rest?
+            rules << []
+            rules.last << "\n" if scanner.matched.include?("\n")
+          end
         when '"'
           rules.last << '"' << scanner.scan(/([^"\\]|\\.)*/)
           # We don't want to enforce that strings are closed,
@@ -228,5 +310,20 @@ END
 
       rules
     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 = [[k.to_s.gsub(/[^\w-]/, "\\\\\\0")]]
+        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
   end
 end