sass4 4.0.0

data/lib/sass/tree/prop_node.rb

@@ -0,0 +1,162 @@
+module Sass::Tree
+  # A static node representing a CSS property.
+  #
+  # @see Sass::Tree
+  class PropNode < Node
+    # The name of the property,
+    # interspersed with {Sass::Script::Tree::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :name
+
+    # The name of the property
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_name
+
+    # The value of the property.
+    #
+    # For most properties, this will just contain a single Node. However, for
+    # CSS variables, it will contain multiple strings and nodes representing
+    # interpolation. Any adjacent strings will be merged together.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :value
+
+    # The value of the property
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @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 [Integer]
+    attr_accessor :tabs
+
+    # 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
+
+    # Whether this represents a CSS custom property.
+    #
+    # @return [Boolean]
+    def custom_property?
+      name.first.is_a?(String) && name.first.start_with?("--")
+    end
+
+    # @param name [Array<String, Sass::Script::Tree::Node>] See \{#name}
+    # @param value [Array<String, 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, prop_syntax)
+      @name = Sass::Util.strip_string_array(
+        Sass::Util.merge_adjacent_strings(name))
+      @value = Sass::Util.merge_adjacent_strings(value)
+      @value = Sass::Util.strip_string_array(@value) unless custom_property?
+      @tabs = 0
+      @prop_syntax = prop_syntax
+      super()
+    end
+
+    # Compares the names and values of two properties.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      self.class == other.class && name == other.name && value == other.value && super
+    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.
+    #
+    # @return [String] The message
+    def pseudo_class_selector_message
+      if @prop_syntax == :new ||
+          custom_property? ||
+          !value.first.is_a?(Sass::Script::Tree::Literal) ||
+          !value.first.value.is_a?(Sass::Script::Value::String) ||
+          !value.first.value.value.empty?
+        return ""
+      end
+
+      "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
+    end
+
+    # Computes the Sass or SCSS code for the variable declaration.
+    # This is like \{#to\_scss} or \{#to\_sass},
+    # except it doesn't print any child properties or a trailing semicolon.
+    #
+    # @param opts [{Symbol => Object}] The options hash for the tree.
+    # @param fmt [Symbol] `:scss` or `:sass`.
+    def declaration(opts = {:old => @prop_syntax == :old}, fmt = :sass)
+      name = self.name.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
+      value = self.value.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
+      value = "(#{value})" if value_needs_parens?
+
+      if name[0] == ?:
+        raise Sass::SyntaxError.new("The \"#{name}: #{value}\"" +
+                                    " hack is not allowed in the Sass indented syntax")
+      end
+
+      # The indented syntax doesn't support newlines in custom property values,
+      # but we can losslessly convert them to spaces instead.
+      value = value.tr("\n", " ") if fmt == :sass
+
+      old = opts[:old] && fmt == :sass
+      "#{old ? ':' : ''}#{name}#{old ? '' : ':'}#{custom_property? ? '' : ' '}#{value}".rstrip
+    end
+
+    # A property node is invisible if its value is empty.
+    #
+    # @return [Boolean]
+    def invisible?
+      !custom_property? && resolved_value.empty?
+    end
+
+    private
+
+    # Returns whether \{#value} neesd parentheses in order to be parsed
+    # properly as division.
+    def value_needs_parens?
+      return false if custom_property?
+
+      root = value.first
+      root.is_a?(Sass::Script::Tree::Operation) &&
+        root.operator == :div &&
+        root.operand1.is_a?(Sass::Script::Tree::Literal) &&
+        root.operand1.value.is_a?(Sass::Script::Value::Number) &&
+        root.operand1.value.original.nil? &&
+        root.operand2.is_a?(Sass::Script::Tree::Literal) &&
+        root.operand2.value.is_a?(Sass::Script::Value::Number) &&
+        root.operand2.value.original.nil?
+    end
+
+    def check!
+      return unless @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.")
+    end
+  end
+end

data/lib/sass/tree/return_node.rb

@@ -0,0 +1,19 @@
+module Sass
+  module Tree
+    # A dynamic node representing returning from a function.
+    #
+    # @see Sass::Tree
+    class ReturnNode < Node
+      # The expression to return.
+      #
+      # @return [Script::Tree::Node]
+      attr_accessor :expr
+
+      # @param expr [Script::Tree::Node] The expression to return
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
+    end
+  end
+end

data/lib/sass/tree/root_node.rb

@@ -0,0 +1,44 @@
+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
+
+      # 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)
+        Visitors::Extend.visit(result, extends)
+        result
+      end
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -0,0 +1,153 @@
+require 'pathname'
+
+module Sass::Tree
+  # A static node representing a CSS rule.
+  #
+  # @see Sass::Tree
+  class RuleNode < Node
+    # The character used to include the parent selector
+    PARENT = '&'
+
+    # The CSS selector for this rule,
+    # interspersed with {Sass::Script::Tree::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
+    #
+    # @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
+    # 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::Perform} has been run.
+    #
+    # @return [Selector::CommaSequence]
+    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 [Integer]
+    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
+
+    # 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>, Sass::Selector::CommaSequence]
+    #   The CSS rule, either unparsed or parsed.
+    # @param selector_source_range [Sass::Source::Range]
+    def initialize(rule, selector_source_range = nil)
+      if rule.is_a?(Sass::Selector::CommaSequence)
+        @rule = [rule.to_s]
+        @parsed_rules = rule
+      else
+        merged = Sass::Util.merge_adjacent_strings(rule)
+        @rule = Sass::Util.strip_string_array(merged)
+        try_to_parse_non_interpolated_rules
+      end
+      @selector_source_range = selector_source_range
+      @tabs = 0
+      super()
+    end
+
+    # If we've precached the parsed selector, set the line on it, too.
+    def line=(line)
+      @parsed_rules.line = line if @parsed_rules
+      super
+    end
+
+    # If we've precached the parsed selector, set the filename on it, too.
+    def filename=(filename)
+      @parsed_rules.filename = filename if @parsed_rules
+      super
+    end
+
+    # Compares the contents of two rules.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      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)
+      @rule = Sass::Util.strip_string_array(
+        Sass::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
+      try_to_parse_non_interpolated_rules
+    end
+
+    # @return [Boolean] Whether or not this rule is continued on the next line
+    def continued?
+      last = @rule.last
+      last.is_a?(String) && last[-1] == ?,
+    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::DEFAULT_PARSER.escape(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.invisible?}
+    end
+
+    private
+
+    def try_to_parse_non_interpolated_rules
+      @parsed_rules = nil
+      return unless @rule.all? {|t| t.is_a?(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 = nil
+      warnings = Sass.logger.capture do
+        parser = Sass::SCSS::StaticParser.new(
+          Sass::Util.strip_except_escapes(@rule.join), nil, nil, 1)
+        @parsed_rules = parser.parse_selector rescue nil
+      end
+
+      # If parsing produces a warning, throw away the result so we can parse
+      # later with the real filename info.
+      @parsed_rules = nil unless warnings.empty?
+    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

@@ -0,0 +1,36 @@
+module Sass
+  module Tree
+    # A dynamic node representing a variable definition.
+    #
+    # @see Sass::Tree
+    class VariableNode < Node
+      # The name of the variable.
+      # @return [String]
+      attr_reader :name
+
+      # The parse tree for the variable value.
+      # @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::Tree::Node] See \{#expr}
+      # @param guarded [Boolean] See \{#guarded}
+      # @param global [Boolean] See \{#global}
+      def initialize(name, expr, guarded, global)
+        @name = name
+        @expr = expr
+        @guarded = guarded
+        @global = global
+        super()
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# Visitors are used to traverse the Sass parse tree.
+# Visitors should extend {Visitors::Base},
+# which provides a small amount of scaffolding for traversal.
+module Sass::Tree::Visitors
+  # The abstract base class for Sass visitors.
+  # Visitors should extend this class,
+  # then implement `visit_*` methods for each node they care about
+  # (e.g. `visit_rule` for {RuleNode} or `visit_for` for {ForNode}).
+  # These methods take the node in question as argument.
+  # They may `yield` to visit the child nodes of the current node.
+  #
+  # *Note*: due to the unusual nature of {Sass::Tree::IfNode},
+  # special care must be taken to ensure that it is properly handled.
+  # In particular, there is no built-in scaffolding
+  # for dealing with the return value of `@else` nodes.
+  #
+  # @abstract
+  class Base
+    # Runs the visitor on a tree.
+    #
+    # @param root [Tree::Node] The root node of the Sass tree.
+    # @return [Object] The return value of \{#visit} for the root node.
+    def self.visit(root)
+      new.send(:visit, root)
+    end
+
+    protected
+
+    # Runs the visitor on the given node.
+    # This can be overridden by subclasses that need to do something for each node.
+    #
+    # @param node [Tree::Node] The node to visit.
+    # @return [Object] The return value of the `visit_*` method for this node.
+    def visit(node)
+      if respond_to?(node.class.visit_method, true)
+        send(node.class.visit_method, node) {visit_children(node)}
+      else
+        visit_children(node)
+      end
+    end
+
+    # Visit the child nodes for a given node.
+    # This can be overridden by subclasses that need to do something
+    # with the child nodes' return values.
+    #
+    # This method is run when `visit_*` methods `yield`,
+    # and its return value is returned from the `yield`.
+    #
+    # @param parent [Tree::Node] The parent node of the children to visit.
+    # @return [Array<Object>] The return values of the `visit_*` methods for the children.
+    def visit_children(parent)
+      parent.children.map {|c| visit(c)}
+    end
+
+    # Returns the name of a node as used in the `visit_*` method.
+    #
+    # @param [Tree::Node] node The node.
+    # @return [String] The name.
+    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.
+    # This exists to ensure that the contents of the `@else` clause get visited.
+    def visit_if(node)
+      yield
+      visit(node.else) if node.else
+      node
+    end
+  end
+end