haml-edge 2.3.209 → 2.3.210

data/lib/sass/selector.rb

@@ -0,0 +1,353 @@
+require 'sass/selector/simple'
+require 'sass/selector/abstract_sequence'
+require 'sass/selector/comma_sequence'
+require 'sass/selector/sequence'
+require 'sass/selector/simple_sequence'
+
+module Sass
+  # A namespace for nodes in the parse tree for selectors.
+  #
+  # {CommaSequence} is the toplevel seelctor,
+  # representing a comma-separated sequence of {Sequence}s,
+  # such as `foo bar, baz bang`.
+  # {Sequence} is the next level,
+  # representing {SimpleSequence}s separated by combinators (e.g. descendant or child),
+  # such as `foo bar` or `foo > bar baz`.
+  # {SimpleSequence} is a sequence of selectors that all apply to a single element,
+  # such as `foo.bar[attr=val]`.
+  # Finally, {Simple} is the superclass of the simplest selectors,
+  # such as `.foo` or `#bar`.
+  module Selector
+    # A parent-referencing selector (`&` in Sass).
+    # The function of this is to be replaced by the parent selector
+    # in the nested hierarchy.
+    class Parent < Simple
+      # @see Selector#to_a
+      def to_a
+        ["&"]
+      end
+
+      # Always raises an exception.
+      #
+      # @raise [Sass::SyntaxError] Parent selectors should be resolved before unification
+      # @see Selector#unify
+      def unify(sels)
+        raise Sass::SyntaxError.new("[BUG] Cannot unify parent selectors.")
+      end
+    end
+
+    # A class selector (e.g. `.foo`).
+    class Class < Simple
+      # The class name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # @param name [Array<String, Sass::Script::Node>] The class name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [".", *@name]
+      end
+    end
+
+    # An id selector (e.g. `#foo`).
+    class Id < Simple
+      # The id name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # @param name [Array<String, Sass::Script::Node>] The id name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_a
+      def to_a
+        ["#", *@name]
+      end
+
+      # Returns `nil` if `sels` contains an {Id} selector
+      # with a different name than this one.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        return if sels.any? {|sel2| sel2.is_a?(Id) && self.name != sel2.name}
+        super
+      end
+    end
+
+    # A universal selector (`*` in CSS).
+    class Universal < Simple
+      # The selector namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :namespace
+
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
+      def initialize(namespace)
+        @namespace = namespace
+      end
+
+      # @see Selector#to_a
+      def to_a
+        @namespace ? @namespace + ["|*"] : ["*"]
+      end
+
+      # Unification of a universal selector is somewhat complicated,
+      # especially when a namespace is specified.
+      # If there is no namespace specified
+      # or any namespace is specified (namespace `"*"`),
+      # then `sel` is returned without change
+      # (unless it's empty, in which case `"*"` is required).
+      #
+      # If a namespace is specified
+      # but `sel` does not specify a namespace,
+      # then the given namespace is applied to `sel`,
+      # either by adding this {Universal} selector
+      # or applying this namespace to an existing {Element} selector.
+      #
+      # If both this selector *and* `sel` specify namespaces,
+      # those namespaces are unified via {Simple#unify_namespaces}
+      # and the unified namespace is used, if possible.
+      #
+      # @todo There are lots of cases that this documentation specifies;
+      #   make sure we thoroughly test **all of them**.
+      # @todo Keep track of whether a default namespace has been declared
+      #   and handle namespace-unspecified selectors accordingly.
+      # @todo If any branch of a CommaSequence ends up being just `"*"`,
+      #   then all other branches should be eliminated
+      #
+      # @see Selector#unify
+      def unify(sels)
+        name =
+          case sels.first
+          when Universal; :universal
+          when Element; sels.first.name
+          else
+            return [self] + sels unless namespace.nil? || namespace == ['*']
+            return sels unless sels.empty?
+            return [self]
+          end
+
+        ns, accept = unify_namespaces(namespace, sels.first.namespace)
+        return unless accept
+        [name == :universal ? Universal.new(ns) : Element.new(name, ns)] + sels[1..-1]
+      end
+    end
+
+    # An element selector (e.g. `h1`).
+    class Element < Simple
+      # The element name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The selector namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :namespace
+
+      # @param name [Array<String, Sass::Script::Node>] The element name
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
+      def initialize(name, namespace)
+        @name = name
+        @namespace = namespace
+      end
+
+      # @see Selector#to_a
+      def to_a
+        @namespace ? @namespace + ["|"] + @name : @name
+      end
+
+      # Unification of an element selector is somewhat complicated,
+      # especially when a namespace is specified.
+      # First, if `sel` contains another {Element} with a different \{#name},
+      # then the selectors can't be unified and `nil` is returned.
+      #
+      # Otherwise, if `sel` doesn't specify a namespace,
+      # or it specifies any namespace (via `"*"`),
+      # then it's returned with this element selector
+      # (e.g. `.foo` becomes `a.foo` or `svg|a.foo`).
+      # Similarly, if this selector doesn't specify a namespace,
+      # the namespace from `sel` is used.
+      #
+      # If both this selector *and* `sel` specify namespaces,
+      # those namespaces are unified via {Simple#unify_namespaces}
+      # and the unified namespace is used, if possible.
+      #
+      # @todo There are lots of cases that this documentation specifies;
+      #   make sure we thoroughly test **all of them**.
+      # @todo Keep track of whether a default namespace has been declared
+      #   and handle namespace-unspecified selectors accordingly.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        case sels.first
+        when Universal;
+        when Element; return unless name == sels.first.name
+        else return [self] + sels
+        end
+
+        ns, accept = unify_namespaces(namespace, sels.first.namespace)
+        return unless accept
+        [Element.new(name, ns)] + sels[1..-1]
+      end
+    end
+
+    # Selector interpolation (`#{}` in Sass).
+    class Interpolation < Simple
+      # The script to run.
+      #
+      # @return [Sass::Script::Node]
+      attr_reader :script
+
+      # @param script [Sass::Script::Node] The script to run
+      def initialize(script)
+        @script = script
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [@script]
+      end
+
+      # Always raises an exception.
+      #
+      # @raise [Sass::SyntaxError] Interpolation selectors should be resolved before unification
+      # @see Selector#unify
+      def unify(sels)
+        raise Sass::SyntaxError.new("[BUG] Cannot unify interpolation selectors.")
+      end
+    end
+
+    # An attribute selector (e.g. `[href^="http://"]`).
+    class Attribute < Simple
+      # The attribute name.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The attribute namespace.
+      # `nil` means the default namespace,
+      # `[""]` means no namespace,
+      # `["*"]` means any namespace.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :namespace
+
+      # The matching operator, e.g. `"="` or `"^="`.
+      #
+      # @return [String]
+      attr_reader :operator
+
+      # The right-hand side of the operator.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :value
+
+      # @param name [Array<String, Sass::Script::Node>] The attribute name
+      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
+      # @param operator [String] The matching operator, e.g. `"="` or `"^="`
+      # @param value [Array<String, Sass::Script::Node>] See \{#value}
+      def initialize(name, namespace, operator, value)
+        @name = name
+        @namespace = namespace
+        @operator = operator
+        @value = value
+      end
+
+      # @see Selector#to_a
+      def to_a
+        res = ["["]
+        res.concat(@namespace) << "|" if @namespace
+        res.concat @name
+        (res << @operator).concat @value if @value
+        res << "]"
+      end
+    end
+
+    # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`) selector.
+    # It can have arguments (e.g. `:nth-child(2n+1)`).
+    class Pseudo < Simple
+      # The type of the selector.
+      # `:class` if this is a pseudoclass selector,
+      # `:element` if it's a pseudoelement.
+      #
+      # @return [Symbol]
+      attr_reader :type
+
+      # The name of the selector.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      attr_reader :name
+
+      # The argument to the selector,
+      # or `nil` if no argument was given.
+      #
+      # This may include SassScript nodes that will be run during resolution.
+      # Note that this should not include SassScript nodes
+      # after resolution has taken place.
+      #
+      # @return [Array<String, Sass::Script::Node>, nil]
+      attr_reader :arg
+
+      # @param type [Symbol] See \{#type}
+      # @param name [Array<String, Sass::Script::Node>] The name of the selector
+      # @param arg [nil, Array<String, Sass::Script::Node>] The argument to the selector,
+      #   or nil if no argument was given
+      def initialize(type, name, arg)
+        @type = type
+        @name = name
+        @arg = arg
+      end
+
+      # @see Selector#to_a
+      def to_a
+        res = [@type == :class ? ":" : "::"] + @name
+        (res << "(").concat(Haml::Util.strip_string_array(@arg)) << ")" if @arg
+        res
+      end
+
+      # Returns `nil` if this is a pseudoclass selector
+      # and `sels` contains a pseudoclass selector different than this one.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        return if type == :element && sels.any? do |sel|
+          sel.is_a?(Pseudo) && sel.type == :element &&
+            (sel.name != self.name || sel.arg != self.arg)
+        end
+        super
+      end
+    end
+
+    # A negation pseudoclass selector (e.g. `:not(.foo)`).
+    class Negation < Simple
+      # The selector to negate.
+      #
+      # @return [Selector]
+      attr_reader :selector
+
+      # @param [Selector] The selector to negate
+      def initialize(selector)
+        @selector = selector
+      end
+
+      # @see Selector#to_a
+      def to_a
+        [":not("] + @selector.to_a + [")"]
+      end
+    end
+  end
+end

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