sass 3.1.0 → 3.3.0

data/lib/sass/tree/node.rb

@@ -8,13 +8,15 @@ module Sass
   # in addition to nodes for CSS rules and properties.
   # Nodes that only appear in this state are called **dynamic nodes**.
   #
-  # {Tree::Visitors::Perform} creates a static Sass tree, which is different.
-  # It still has nodes for CSS rules and properties
-  # but it doesn't have any dynamic-generation-related nodes.
-  # The nodes in this state are in the same structure as the Sass document:
-  # rules and properties are nested beneath one another.
-  # Nodes that can be in this state or in the dynamic state
-  # are called **static nodes**.
+  # {Tree::Visitors::Perform} creates a static Sass tree, which is
+  # different. It still has nodes for CSS rules and properties but it
+  # doesn't have any dynamic-generation-related nodes. The nodes in
+  # this state are in a similar structure to the Sass document: rules
+  # and properties are nested beneath one another, although the
+  # {Tree::RuleNode} selectors are already in their final state. Nodes
+  # that can be in this state or in the dynamic state are called
+  # **static nodes**; nodes that can only be in this state are called
+  # **solely static nodes**.
   #
   # {Tree::Visitors::Cssize} is then used to create a static CSS tree.
   # This is like a static Sass tree,
@@ -28,10 +30,35 @@ module Sass
     class Node
       include Enumerable
 
+      def self.inherited(base)
+        node_name = base.name.gsub(/.*::(.*?)Node$/, '\\1').downcase
+        base.instance_eval <<-METHODS
+          # @return [Symbol] The name that is used for this node when visiting.
+          def node_name
+            :#{node_name}
+          end
+
+          # @return [Symbol] The method that is used on the visitor to visit nodes of this type.
+          def visit_method
+            :visit_#{node_name}
+          end
+
+          # @return [Symbol] The method name that determines if the parent is invalid.
+          def invalid_child_method_name
+            :"invalid_#{node_name}_child?"
+          end
+
+          # @return [Symbol] The method name that determines if the node is an invalid parent.
+          def invalid_parent_method_name
+            :"invalid_#{node_name}_parent?"
+          end
+        METHODS
+      end
+
       # The child nodes of this node.
       #
       # @return [Array<Tree::Node>]
-      attr_accessor :children
+      attr_reader :children
 
       # Whether or not this node has child nodes.
       # This may be true even when \{#children} is empty,
@@ -45,6 +72,11 @@ module Sass
       # @return [Fixnum]
       attr_accessor :line
 
+      # The source range in the document on which this node appeared.
+      #
+      # @return [Sass::Source::Range]
+      attr_accessor :source_range
+
       # The name of the document on which this node appeared.
       #
       # @return [String]
@@ -65,8 +97,7 @@ module Sass
       # @param options [{Symbol => Object}] The options
       # @see #options
       def options=(options)
-        children.each {|c| c.options = options}
-        @options = options
+        Sass::Tree::Visitors::SetOptions.visit(self, options)
       end
 
       # @private
@@ -127,31 +158,29 @@ module Sass
 
       # Computes the CSS corresponding to this static CSS tree.
       #
-      # @return [String, nil] The resulting CSS
+      # @return [String] The resulting CSS
       # @see Sass::Tree
-      def to_s
-        Sass::Tree::Visitors::ToCss.visit(self)
+      def css
+        Sass::Tree::Visitors::ToCss.new.visit(self)
       end
 
-      # Converts a static CSS tree (e.g. the output of \{Tree::Visitors::Cssize})
-      # into another static CSS tree,
-      # with the given extensions applied to all relevant {RuleNode}s.
+      # Computes the CSS corresponding to this static CSS tree, along with
+      # the respective source map.
       #
-      # @todo Link this to the reference documentation on `@extend`
-      #   when such a thing exists.
+      # @return [(String, Sass::Source::Map)] The resulting CSS and the source map
+      # @see Sass::Tree
+      def css_with_sourcemap
+        visitor = Sass::Tree::Visitors::ToCss.new(:build_source_mapping)
+        result = visitor.visit(self)
+        return result, visitor.source_mapping
+      end
+
+      # Returns a representation of the node for debugging purposes.
       #
-      # @param extends [Sass::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
+      # @return [String]
+      def inspect
+        return self.class.to_s unless has_children
+        "(#{self.class} #{children.map {|c| c.inspect}.join(' ')})"
       end
 
       # Iterates through each node in the tree rooted at this node
@@ -159,9 +188,9 @@ module Sass
       #
       # @yield node
       # @yieldparam node [Node] a node in the tree
-      def each(&block)
+      def each
         yield self
-        children.each {|c| c.each(&block)}
+        children.each {|c| c.each {|n| yield n}}
       end
 
       # Converts a node to Sass code that will generate it.
@@ -185,9 +214,14 @@ module Sass
       #
       # @return [Node]
       def deep_copy
-        node = dup
-        node.children = children.map {|c| c.deep_copy}
-        node
+        Sass::Tree::Visitors::DeepCopy.visit(self)
+      end
+
+      # Whether or not this node bubbles up through RuleNodes.
+      #
+      # @return [Boolean]
+      def bubbles?
+        false
       end
 
       protected

data/lib/sass/tree/prop_node.rb

@@ -1,14 +1,14 @@
 module Sass::Tree
-  # A static node reprenting a CSS property.
+  # A static node representing a CSS property.
   #
   # @see Sass::Tree
   class PropNode < Node
     # The name of the property,
-    # interspersed with {Sass::Script::Node}s
+    # interspersed with {Sass::Script::Tree::Node}s
     # representing `#{}`-interpolation.
     # Any adjacent strings will be merged together.
     #
-    # @return [Array<String, Sass::Script::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :name
 
     # The name of the property
@@ -20,14 +20,9 @@ module Sass::Tree
 
     # The value of the property.
     #
-    # @return [Sass::Script::Node]
+    # @return [Sass::Script::Tree::Node]
     attr_accessor :value
 
-    # Whether the property was marked as !important.
-    #
-    # @return [Boolean]
-    attr_accessor :important
-
     # The value of the property
     # after any interpolated SassScript has been resolved.
     # Only set once \{Tree::Visitors::Perform} has been run.
@@ -47,18 +42,26 @@ module Sass::Tree
     # @return [Fixnum]
     attr_accessor :tabs
 
-    # @param name [Array<String, Sass::Script::Node>] See \{#name}
-    # @param value [Sass::Script::Node] See \{#value}
-    # @param important [Boolean] whether this is an !important property
+    # The source range in which the property name appears.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :name_source_range
+
+    # The source range in which the property value appears.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :value_source_range
+
+    # @param name [Array<String, Sass::Script::Tree::Node>] See \{#name}
+    # @param value [Sass::Script::Tree::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, important, prop_syntax)
+    def initialize(name, value, prop_syntax)
       @name = Sass::Util.strip_string_array(
         Sass::Util.merge_adjacent_strings(name))
       @value = value
       @tabs = 0
       @prop_syntax = prop_syntax
-      @important = important
       super()
     end
 
@@ -77,7 +80,13 @@ module Sass::Tree
     #
     # @return [String] The message
     def pseudo_class_selector_message
-      return "" if @prop_syntax == :new || !value.is_a?(Sass::Script::String) || !value.value.empty?
+      if @prop_syntax == :new ||
+          !value.is_a?(Sass::Script::Tree::Literal) ||
+          !value.value.is_a?(Sass::Script::Value::String) ||
+          !value.value.value.empty?
+        return ""
+      end
+
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
@@ -90,13 +99,21 @@ module Sass::Tree
     def declaration(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")
+        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 ? '' : ':'
-      "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}#{' !important' if important}".rstrip
+      "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
+    end
+
+    # A property node is invisible if its value is empty.
+    #
+    # @return [Boolean]
+    def invisible?
+      resolved_value.empty?
     end
 
     private
@@ -104,10 +121,8 @@ module Sass::Tree
     def check!
       if @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
         raise Sass::SyntaxError.new(
-          "Illegal property syntax: can't use #{@prop_syntax} syntax when :property_syntax => #{@options[:property_syntax].inspect} is set.")
-      elsif resolved_value.empty?
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value)." +
-          pseudo_class_selector_message)
+          "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
+          ":property_syntax => #{@options[:property_syntax].inspect} is set.")
       end
     end
 
@@ -120,36 +135,37 @@ module Sass::Tree
       private
 
       def val_to_sass_comma(node, opts)
-        return node unless node.is_a?(Sass::Script::Operation)
+        return node unless node.is_a?(Sass::Script::Tree::Operation)
         return val_to_sass_concat(node, opts) unless node.operator == :comma
 
-        Sass::Script::Operation.new(
+        Sass::Script::Tree::Operation.new(
           val_to_sass_concat(node.operand1, opts),
           val_to_sass_comma(node.operand2, opts),
           node.operator)
       end
 
       def val_to_sass_concat(node, opts)
-        return node unless node.is_a?(Sass::Script::Operation)
+        return node unless node.is_a?(Sass::Script::Tree::Operation)
         return val_to_sass_div(node, opts) unless node.operator == :space
 
-        Sass::Script::Operation.new(
+        Sass::Script::Tree::Operation.new(
           val_to_sass_div(node.operand1, opts),
           val_to_sass_concat(node.operand2, opts),
           node.operator)
       end
 
       def val_to_sass_div(node, opts)
-        unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
-            node.operand1.is_a?(Sass::Script::Number) &&
-            node.operand2.is_a?(Sass::Script::Number) &&
-            (!node.operand1.original || !node.operand2.original)
+        unless node.is_a?(Sass::Script::Tree::Operation) && node.operator == :div &&
+            node.operand1.is_a?(Sass::Script::Tree::Literal) &&
+            node.operand1.value.is_a?(Sass::Script::Value::Number) &&
+            node.operand2.is_a?(Sass::Script::Tree::Literal) &&
+            node.operand2.value.is_a?(Sass::Script::Value::Number) &&
+            (!node.operand1.value.original || !node.operand2.value.original)
           return node
         end
 
-        Sass::Script::String.new("(#{node.to_sass(opts)})")
+        Sass::Script::Value::String.new("(#{node.to_sass(opts)})")
       end
-
     end
   end
 end

data/lib/sass/tree/return_node.rb

@@ -5,10 +5,11 @@ module Sass
     # @see Sass::Tree
     class ReturnNode < Node
       # The expression to return.
-      # @type [Script::Node]
-      attr_reader :expr
+      #
+      # @return [Script::Tree::Node]
+      attr_accessor :expr
 
-      # @param expr [Script::Node] The expression to return
+      # @param expr [Script::Tree::Node] The expression to return
       def initialize(expr)
         @expr = expr
         super()

data/lib/sass/tree/root_node.rb

@@ -13,15 +13,31 @@ module Sass
         @template = template
       end
 
-      # Runs the dynamic Sass code *and* computes the CSS for the tree.
-      # @see #to_s
+      # Runs the dynamic Sass code and computes the CSS for the tree.
+      #
+      # @return [String] The compiled CSS.
       def render
+        css_tree.css
+      end
+
+      # Runs the dynamic Sass code and computes the CSS for the tree, along with
+      # the sourcemap.
+      #
+      # @return [(String, Sass::Source::Map)] The compiled CSS, as well as
+      #   the source map. @see #render
+      def render_with_sourcemap
+        css_tree.css_with_sourcemap
+      end
+
+      private
+
+      def css_tree
         Visitors::CheckNesting.visit(self)
         result = Visitors::Perform.visit(self)
         Visitors::CheckNesting.visit(result) # Check again to validate mixins
         result, extends = Visitors::Cssize.visit(result)
-        result = result.do_extend(extends) unless extends.empty?
-        result.to_s
+        Visitors::Extend.visit(result, extends)
+        result
       end
     end
   end

data/lib/sass/tree/rule_node.rb

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'uri'
 
 module Sass::Tree
   # A static node reprenting a CSS rule.
@@ -10,24 +9,24 @@ module Sass::Tree
     PARENT = '&'
 
     # The CSS selector for this rule,
-    # interspersed with {Sass::Script::Node}s
+    # interspersed with {Sass::Script::Tree::Node}s
     # representing `#{}`-interpolation.
     # Any adjacent strings will be merged together.
     #
-    # @return [Array<String, Sass::Script::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :rule
 
-    # The CSS selector for this rule,
-    # without any unresolved interpolation
-    # but with parent references still intact.
-    # It's only set once {Tree::Node#perform} has been called.
+    # The CSS selector for this rule, without any unresolved
+    # interpolation but with parent references still intact. It's only
+    # guaranteed to be set once {Tree::Visitors::Perform} has been
+    # run, but it may be set before then for optimization reasons.
     #
     # @return [Selector::CommaSequence]
     attr_accessor :parsed_rules
 
-    # The CSS selector for this rule,
-    # without any unresolved interpolation or parent references.
-    # It's only set once {Tree::Visitors::Cssize} has been run.
+    # The CSS selector for this rule, without any unresolved
+    # interpolation or parent references. It's only set once
+    # {Tree::Visitors::Perform} has been run.
     #
     # @return [Selector::CommaSequence]
     attr_accessor :resolved_rules
@@ -44,17 +43,30 @@ module Sass::Tree
     # @return [Fixnum]
     attr_accessor :tabs
 
+    # The entire selector source range for this rule.
+    # @return [Sass::Source::Range]
+    attr_accessor :selector_source_range
+
     # 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 stack trace.
+    # This is only readable in a CSS tree as it is written during the perform step
+    # and only when the :trace_selectors option is set.
+    #
+    # @return [String]
+    attr_accessor :stack_trace
+
+    # @param rule [Array<String, Sass::Script::Tree::Node>]
+    # @param selector_source_range [Sass::Source::Range]
     #   The CSS rule. See \{#rule}
-    def initialize(rule)
+    def initialize(rule, selector_source_range = nil)
       merged = Sass::Util.merge_adjacent_strings(rule)
       @rule = Sass::Util.strip_string_array(merged)
+      @selector_source_range = selector_source_range
       @tabs = 0
       try_to_parse_non_interpolated_rules
       super()
@@ -96,23 +108,20 @@ module Sass::Tree
       last.is_a?(String) && last[-1] == ?,
     end
 
-    # Extends this Rule's selector with the given `extends`.
-    #
-    # @see Node#do_extend
-    def do_extend(extends)
-      node = dup
-      node.resolved_rules = resolved_rules.do_extend(extends)
-      node
-    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).
+    # 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}
+      {:filename => filename && ("file://" + Sass::Util.escape_uri(File.expand_path(filename))),
+       :line => line}
+    end
+
+    # A rule node is invisible if it has only placeholder selectors.
+    def invisible?
+      resolved_rules.members.all? {|seq| seq.has_placeholder?}
     end
 
     private
@@ -121,8 +130,10 @@ module Sass::Tree
       if @rule.all? {|t| t.kind_of?(String)}
         # We don't use real filename/line info because we don't have it yet.
         # When we get it, we'll set it on the parsed rules if possible.
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, 1)
-        @parsed_rules = parser.parse_selector('') rescue nil
+        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, '', nil, 1)
+        # rubocop:disable RescueModifier
+        @parsed_rules = parser.parse_selector rescue nil
+        # rubocop:enable RescueModifier
       end
     end
   end

data/lib/sass/tree/supports_node.rb

@@ -0,0 +1,38 @@
+module Sass::Tree
+  # A static node representing a `@supports` rule.
+  #
+  # @see Sass::Tree
+  class SupportsNode < DirectiveNode
+    # The name, which may include a browser prefix.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # The supports condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :condition
+
+    # @param condition [Sass::Supports::Condition] See \{#condition}
+    def initialize(name, condition)
+      @name = name
+      @condition = condition
+      super('')
+    end
+
+    # @see DirectiveNode#value
+    def value; raise NotImplementedError; end
+
+    # @see DirectiveNode#resolved_value
+    def resolved_value
+      @resolved_value ||= "@#{name} #{condition.to_css}"
+    end
+
+    # True when the directive has no visible children.
+    #
+    # @return [Boolean]
+    def invisible?
+      children.all? {|c| c.invisible?}
+    end
+  end
+end

data/lib/sass/tree/trace_node.rb

@@ -0,0 +1,33 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A solely static node left over after a mixin include or @content has been performed.
+  # Its sole purpose is to wrap exceptions to add to the backtrace.
+  #
+  # @see Sass::Tree
+  class TraceNode < Node
+    # The name of the trace entry to add.
+    #
+    # @return [String]
+    attr_reader :name
+
+    # @param name [String] The name of the trace entry to add.
+    def initialize(name)
+      @name = name
+      self.has_children = true
+      super()
+    end
+
+    # Initializes this node from an existing node.
+    # @param name [String] The name of the trace entry to add.
+    # @param node [Node] The node to copy information from.
+    # @return [TraceNode]
+    def self.from_node(name, node)
+      trace = new(name)
+      trace.line = node.line
+      trace.filename = node.filename
+      trace.options = node.options
+      trace
+    end
+  end
+end

data/lib/sass/tree/variable_node.rb

@@ -9,20 +9,26 @@ module Sass
       attr_reader :name
 
       # The parse tree for the variable value.
-      # @return [Script::Node]
-      attr_reader :expr
+      # @return [Script::Tree::Node]
+      attr_accessor :expr
 
       # Whether this is a guarded variable assignment (`!default`).
       # @return [Boolean]
       attr_reader :guarded
 
+      # Whether this is a global variable assignment (`!global`).
+      # @return [Boolean]
+      attr_reader :global
+
       # @param name [String] The name of the variable
-      # @param expr [Script::Node] See \{#expr}
+      # @param expr [Script::Tree::Node] See \{#expr}
       # @param guarded [Boolean] See \{#guarded}
-      def initialize(name, expr, guarded)
+      # @param global [Boolean] See \{#global}
+      def initialize(name, expr, guarded, global)
         @name = name
         @expr = expr
         @guarded = guarded
+        @global = global
         super()
       end
     end

data/lib/sass/tree/visitors/base.rb

@@ -32,9 +32,8 @@ module Sass::Tree::Visitors
     # @param node [Tree::Node] The node to visit.
     # @return [Object] The return value of the `visit_*` method for this node.
     def visit(node)
-      method = "visit_#{node_name node}"
-      if self.respond_to?(method)
-        self.send(method, node) {visit_children(node)}
+      if respond_to?(node.class.visit_method, true)
+        send(node.class.visit_method, node) {visit_children(node)}
       else
         visit_children(node)
       end
@@ -53,15 +52,13 @@ module Sass::Tree::Visitors
       parent.children.map {|c| visit(c)}
     end
 
-    NODE_NAME_RE = /.*::(.*?)Node$/
-
     # Returns the name of a node as used in the `visit_*` method.
     #
     # @param [Tree::Node] node The node.
     # @return [String] The name.
-    def node_name(node)
-      @@node_names ||= {}
-      @@node_names[node.class.name] ||= node.class.name.gsub(NODE_NAME_RE, '\\1').downcase
+    def self.node_name(node)
+      Sass::Util.deprecated(self, "Call node.class.node_name instead.")
+      node.class.node_name
     end
 
     # `yield`s, then runs the visitor on the `@else` clause if the node has one.