haml 3.0.0.beta.3 → 3.0.0.rc.1

data/lib/sass/tree/comment_node.rb

@@ -72,6 +72,7 @@ module Sass::Tree
       content.rstrip + "\n"
     end
 
+    # @see Node#to_scss
     def to_scss(tabs, opts = {})
       spaces = ('  ' * [tabs - value[/^ */].size, 0].max)
       if silent

data/lib/sass/tree/debug_node.rb

@@ -12,6 +12,7 @@ module Sass
 
       protected
 
+      # @see Node#to_src
       def to_src(tabs, opts, fmt)
         "#{'  ' * tabs}@debug #{@expr.to_sass(opts)}#{semi fmt}\n"
       end

data/lib/sass/tree/directive_node.rb

@@ -22,6 +22,7 @@ module Sass::Tree
 
     protected
 
+    # @see Node#to_src
     def to_src(tabs, opts, fmt)
       res = "#{'  ' * tabs}#{value}"
       return res + "#{semi fmt}\n" if children.empty?

data/lib/sass/tree/extend_node.rb

@@ -0,0 +1,60 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A static node reprenting an `@extend` directive.
+  #
+  # @see Sass::Tree
+  class ExtendNode < Node
+    # @param selector [Array<String, Sass::Script::Node>]
+    #   The CSS selector to extend,
+    #   interspersed with {Sass::Script::Node}s
+    #   representing `#{}`-interpolation.
+    def initialize(selector)
+      @selector = selector
+      super()
+    end
+
+    # Registers this extension in the `extends` subset map.
+    #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
+    # @param parent [RuleNode] The parent node of this node
+    # @see Node#cssize
+    def cssize(extends, parent)
+      @resolved_selector.members.each do |seq|
+        if seq.members.size > 1
+          raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
+        end
+
+        sseq = seq.members.first
+        if !sseq.is_a?(Sass::Selector::SimpleSequence)
+          raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
+        end
+
+        sel = sseq.members
+        parent.resolved_rules.members.each do |seq|
+          if !seq.members.last.is_a?(Sass::Selector::SimpleSequence)
+            raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
+          end
+
+          extends[sel] = seq
+        end
+      end
+
+      []
+    end
+
+    protected
+
+    # Runs SassScript interpolation in the selector,
+    # and then parses the result into a {Sass::Selector::CommaSequence}.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @resolved_selector = Sass::SCSS::CssParser.new(run_interp(@selector, environment)).
+        parse_selector(self.line, self.filename)
+      super
+    end
+  end
+end

data/lib/sass/tree/for_node.rb

@@ -20,6 +20,7 @@ module Sass::Tree
 
     protected
 
+    # @see Node#to_src
     def to_src(tabs, opts, fmt)
       to = @exclusive ? "to" : "through"
       "#{'  ' * tabs}@for $#{dasherize(@var, opts)} from #{@from.to_sass(opts)} #{to} #{@to.to_sass(opts)}" +

data/lib/sass/tree/if_node.rb

@@ -30,6 +30,7 @@ module Sass::Tree
       @last_else = node
     end
 
+    # @see Node#options=
     def options=(options)
       super
       self.else.options = options if self.else
@@ -37,6 +38,7 @@ module Sass::Tree
 
     protected
 
+    # @see Node#to_src
     def to_src(tabs, opts, fmt, is_else = false)
       name =
         if !is_else; "if"

data/lib/sass/tree/import_node.rb

@@ -28,10 +28,12 @@ module Sass
         @full_filename ||= import
       end
 
+      # @see Node#to_sass
       def to_sass(tabs = 0, opts = {})
         "#{'  ' * tabs}@import #{@imported_filename}\n"
       end
 
+      # @see Node#to_scss
       def to_scss(tabs = 0, opts = {})
         "#{'  ' * tabs}@import \"#{@imported_filename}\";\n"
       end

data/lib/sass/tree/mixin_def_node.rb

@@ -16,6 +16,7 @@ module Sass
 
       protected
 
+      # @see Node#to_src
       def to_src(tabs, opts, fmt)
         args =
           if @args.empty?

data/lib/sass/tree/mixin_node.rb

@@ -22,22 +22,38 @@ module Sass::Tree
     end
 
     # @see Node#cssize
-    def cssize(parent = nil)
-      _cssize(parent) # Pass on the parent even if it's not a MixinNode
+    def cssize(extends, parent = nil)
+      _cssize(extends, parent) # Pass on the parent even if it's not a MixinNode
     end
 
     protected
 
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {MixinNode}s.
+    #
+    # @param child [Tree::Node] A potential child node
+    # @return [Boolean, String] Whether or not the child node is valid,
+    #   as well as the error message to display if it is invalid
+    def invalid_child?(child)
+      super unless child.is_a?(ExtendNode)
+    end
+
+    # @see Node#to_src
     def to_src(tabs, opts, fmt)
       args = '(' + @args.map {|a| a.to_sass(opts)}.join(", ") + ')' unless @args.empty?
       "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{args}#{semi fmt}\n"
     end
 
     # @see Node#_cssize
-    def _cssize(parent)
-      children.map {|c| c.cssize(parent)}.flatten
+    def _cssize(extends, parent)
+      children.map do |c|
+        parent.check_child! c
+        c.cssize(extends, parent)
+      end.flatten
     rescue Sass::SyntaxError => e
-      e.modify_backtrace(:mixin => @name, :line => line)
+      e.modify_backtrace(:mixin => @name, :filename => filename, :line => line)
       e.add_backtrace(:filename => filename, :line => line)
       raise e
     end

data/lib/sass/tree/node.rb

@@ -89,11 +89,20 @@ module Sass
       # @see #invalid_child?
       def <<(child)
         return if child.nil?
+        check_child! child
+        self.has_children = true
+        @children << child
+      end
+
+      # Raises an error if the given child node is invalid.
+      #
+      # @param child [Tree::Node] The child node
+      # @raise [Sass::SyntaxError] if `child` is invalid
+      # @see #invalid_child?
+      def check_child!(child)
         if msg = invalid_child?(child)
           raise Sass::SyntaxError.new(msg, :line => child.line)
         end
-        self.has_children = true
-        @children << child
       end
 
       # Compares this node and another object (only other {Tree::Node}s will be equal).
@@ -116,7 +125,10 @@ module Sass
       # @see #perform
       # @see #to_s
       def render
-        perform(Environment.new).cssize.to_s
+        extends = Haml::Util::SubsetMap.new
+        result = perform(Environment.new).cssize(extends)
+        result = result.do_extend(extends) unless extends.empty?
+        result.to_s
       end
 
       # True if \{#to\_s} will return `nil`;
@@ -150,19 +162,42 @@ module Sass
         raise e
       end
 
+      # Converts a static CSS tree (e.g. the output of \{#cssize})
+      # into another static CSS tree,
+      # with the given extensions applied to all relevant {RuleNode}s.
+      #
+      # @todo Link this to the reference documentation on `@extend`
+      #   when such a thing exists.
+      #
+      # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+      #   The extensions to perform on this tree
+      # @return [Tree::Node] The resulting tree of static CSS nodes.
+      # @raise [Sass::SyntaxError] Only if there's a programmer error
+      #   and this is not a static CSS tree
+      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
+
       # Converts a static Sass tree (e.g. the output of \{#perform})
       # into a static CSS tree.
       #
       # \{#cssize} shouldn't be overridden directly;
       # instead, override \{#\_cssize} or \{#cssize!}.
       #
+      # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+      #   The extensions defined for this tree
       # @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
       # @return [Tree::Node] The resulting tree of static nodes
       # @raise [Sass::SyntaxError] if some element of the tree is invalid
       # @see Sass::Tree
-      def cssize(parent = nil)
-        _cssize((parent if parent.class == self.class))
+      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
@@ -237,15 +272,17 @@ module Sass
       # returning the new node.
       # This doesn't modify this node or any of its children.
       #
+      # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+      #   The extensions defined for this tree
       # @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
       # @return [Tree::Node, Array<Tree::Node>] The resulting static CSS nodes
       # @raise [Sass::SyntaxError] if some element of the tree is invalid
       # @see #cssize
       # @see Sass::Tree
-      def _cssize(parent)
+      def _cssize(extends, parent)
         node = dup
-        node.cssize!(parent)
+        node.cssize!(extends, parent)
         node
       end
 
@@ -253,11 +290,13 @@ module Sass
       # This *does* modify this node,
       # but will be run non-destructively by \{#\_cssize\}.
       #
+      # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+      #   The extensions defined for this tree
       # @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 #cssize
-      def cssize!(parent)
-        self.children = children.map {|c| c.cssize(self)}.flatten
+      def cssize!(extends, parent)
+        self.children = children.map {|c| c.cssize(extends, self)}.flatten
       end
 
       # Runs any dynamic Sass code in this particular node.
@@ -322,8 +361,8 @@ module Sass
       # Returns an error message if the given child node is invalid,
       # and false otherwise.
       #
-      # By default, all child nodes except those only allowed at root level
-      # ({Tree::MixinDefNode}, {Tree::ImportNode}) are valid.
+      # By default, all child nodes except those only allowed under specific nodes
+      # ({Tree::MixinDefNode}, {Tree::ImportNode}, {Tree::ExtendNode}) are valid.
       # This is expected to be overriden by subclasses
       # for which some children are invalid.
       #
@@ -336,6 +375,8 @@ module Sass
           "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
 
@@ -366,9 +407,15 @@ module Sass
           (fmt == :sass ? "\n" : " }\n")
       end
 
+      # Convert any underscores in a string into hyphens,
+      # but only if the `:dasherize` option is set.
+      #
+      # @param s [String] The string to convert
+      # @param opts [{Symbol => Object}] The options hash
+      # @return [String] The converted string
       def dasherize(s, opts)
         if opts[:dasherize]
-          s.gsub(/_/,'-')
+          s.gsub('_', '-')
         else
           s
         end

data/lib/sass/tree/prop_node.rb

@@ -68,28 +68,19 @@ module Sass::Tree
     # 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 || !resolved_value.empty?
+      return "" if @prop_syntax == :new || !value.is_a?(Sass::Script::String) || !value.value.empty?
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
     protected
 
+    # @see Node#to_src
     def to_src(tabs, opts, fmt)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
-      if name[0] == ?:
-        raise Sass::SyntaxError.new("The \":#{name}: #{self.class.val_to_sass(value, opts)}\" hack is not allowed in the Sass indented syntax")
-      end
-
-      old = opts[:old] && fmt == :sass
-      initial = old ? ':' : ''
-      mid = old ? '' : ':'
-      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}"
+      res = declaration(tabs, opts, fmt)
       return res + "#{semi fmt}\n" if children.empty?
-      res.rstrip + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
+      res + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
     end
 
     # Computes the CSS for the property.
@@ -103,10 +94,12 @@ module Sass::Tree
 
     # Converts nested properties into flat properties.
     #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
     # @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)
+    def _cssize(extends, parent)
       node = super
       result = node.children.dup
       if !node.resolved_value.empty? || node.children.empty?
@@ -119,9 +112,11 @@ module Sass::Tree
     # Updates the name and indentation of this node based on the parent name
     # and nesting level.
     #
+    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
+    #   The extensions defined for this tree
     # @param parent [PropNode, nil] The parent node of this node,
     #   or nil if the parent isn't a {PropNode}
-    def cssize!(parent)
+    def cssize!(extends, 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
@@ -169,12 +164,16 @@ module Sass::Tree
       end
     end
 
-    def declaration
-      if @prop_syntax == :new
-        "#{resolved_name}: #{resolved_value}"
-      else
-        ":#{resolved_name} #{resolved_value}"
-      end.strip
+    def declaration(tabs = 0, opts = {:old => @prop_syntax == :old}, fmt = :sass)
+      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
+      if name[0] == ?:
+        raise Sass::SyntaxError.new("The \":#{name}: #{self.class.val_to_sass(value, opts)}\" hack is not allowed in the Sass indented syntax")
+      end
+
+      old = opts[:old] && fmt == :sass
+      initial = old ? ':' : ''
+      mid = old ? '' : ':'
+      "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
     end
 
     class << self

data/lib/sass/tree/root_node.rb

@@ -62,6 +62,7 @@ module Sass
 
       protected
 
+      # @see Node#to_src
       def to_src(opts, fmt)
         Haml::Util.enum_cons(children + [nil], 2).map do |child, nxt|
           child.send("to_#{fmt}", 0, opts) +
@@ -75,20 +76,6 @@ module Sass
         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
@@ -106,12 +93,16 @@ module Sass
         return result + "\n"
       end
 
-      # Returns false, because all nodes are allowed at the root of the document
-      # (properties are detected elsewhere post-mixin-resolution).
+      # Returns an error message if the given child node is invalid,
+      # and false otherwise.
+      #
+      # Only property nodes are invalid at root level.
       #
       # @see Node#invalid_child?
       def invalid_child?(child)
-        false
+        return unless child.is_a?(Tree::PropNode)
+        "Properties aren't allowed at the root of a document." +
+          child.pseudo_class_selector_message
       end
     end
   end