sass4 4.0.0

data/lib/sass/tree/each_node.rb

@@ -0,0 +1,24 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@each` loop.
+  #
+  # @see Sass::Tree
+  class EachNode < Node
+    # The names of the loop variables.
+    # @return [Array<String>]
+    attr_reader :vars
+
+    # The parse tree for the list.
+    # @return [Script::Tree::Node]
+    attr_accessor :list
+
+    # @param vars [Array<String>] The names of the loop variables
+    # @param list [Script::Tree::Node] The parse tree for the list
+    def initialize(vars, list)
+      @vars = vars
+      @list = list
+      super()
+    end
+  end
+end

data/lib/sass/tree/error_node.rb

@@ -0,0 +1,18 @@
+module Sass
+  module Tree
+    # A dynamic node representing a Sass `@error` statement.
+    #
+    # @see Sass::Tree
+    class ErrorNode < Node
+      # The expression to print.
+      # @return [Script::Tree::Node]
+      attr_accessor :expr
+
+      # @param expr [Script::Tree::Node] The expression to print
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
+    end
+  end
+end

data/lib/sass/tree/extend_node.rb

@@ -0,0 +1,43 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A static node representing an `@extend` directive.
+  #
+  # @see Sass::Tree
+  class ExtendNode < Node
+    # The parsed selector after interpolation has been resolved.
+    # Only set once {Tree::Visitors::Perform} has been run.
+    #
+    # @return [Selector::CommaSequence]
+    attr_accessor :resolved_selector
+
+    # The CSS selector to extend, interspersed with {Sass::Script::Tree::Node}s
+    # representing `#{}`-interpolation.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :selector
+
+    # The extended selector source range.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :selector_source_range
+
+    # Whether the `@extend` is allowed to match no selectors or not.
+    #
+    # @return [Boolean]
+    def optional?; @optional; end
+
+    # @param selector [Array<String, Sass::Script::Tree::Node>]
+    #   The CSS selector to extend,
+    #   interspersed with {Sass::Script::Tree::Node}s
+    #   representing `#{}`-interpolation.
+    # @param optional [Boolean] See \{ExtendNode#optional?}
+    # @param selector_source_range [Sass::Source::Range] The extended selector source range.
+    def initialize(selector, optional, selector_source_range)
+      @selector = selector
+      @optional = optional
+      @selector_source_range = selector_source_range
+      super()
+    end
+  end
+end

data/lib/sass/tree/for_node.rb

@@ -0,0 +1,36 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@for` loop.
+  #
+  # @see Sass::Tree
+  class ForNode < Node
+    # The name of the loop variable.
+    # @return [String]
+    attr_reader :var
+
+    # The parse tree for the initial expression.
+    # @return [Script::Tree::Node]
+    attr_accessor :from
+
+    # The parse tree for the final expression.
+    # @return [Script::Tree::Node]
+    attr_accessor :to
+
+    # Whether to include `to` in the loop or stop just before.
+    # @return [Boolean]
+    attr_reader :exclusive
+
+    # @param var [String] See \{#var}
+    # @param from [Script::Tree::Node] See \{#from}
+    # @param to [Script::Tree::Node] See \{#to}
+    # @param exclusive [Boolean] See \{#exclusive}
+    def initialize(var, from, to, exclusive)
+      @var = var
+      @from = from
+      @to = to
+      @exclusive = exclusive
+      super()
+    end
+  end
+end

data/lib/sass/tree/function_node.rb

@@ -0,0 +1,44 @@
+module Sass
+  module Tree
+    # A dynamic node representing a function definition.
+    #
+    # @see Sass::Tree
+    class FunctionNode < Node
+      # The name of the function.
+      # @return [String]
+      attr_reader :name
+
+      # The arguments to the function. Each element is a tuple
+      # containing the variable for argument and the parse tree for
+      # the default value of the argument
+      #
+      # @return [Array<Script::Tree::Node>]
+      attr_accessor :args
+
+      # The splat argument for this function, if one exists.
+      #
+      # @return [Script::Tree::Node?]
+      attr_accessor :splat
+
+      # Strips out any vendor prefixes.
+      # @return [String] The normalized name of the directive.
+      def normalized_name
+        @normalized_name ||= name.gsub(/^(?:-[a-zA-Z0-9]+-)?/, '\1')
+      end
+
+      # @param name [String] The function name
+      # @param args [Array<(Script::Tree::Node, Script::Tree::Node)>]
+      #   The arguments for the function.
+      # @param splat [Script::Tree::Node] See \{#splat}
+      def initialize(name, args, splat)
+        @name = name
+        @args = args
+        @splat = splat
+        super()
+
+        return unless %w(and or not).include?(name)
+        raise Sass::SyntaxError.new("Invalid function name \"#{name}\".")
+      end
+    end
+  end
+end

data/lib/sass/tree/if_node.rb

@@ -0,0 +1,52 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@if` statement.
+  #
+  # {IfNode}s are a little odd, in that they also represent `@else` and `@else if`s.
+  # This is done as a linked list:
+  # each {IfNode} has a link (\{#else}) to the next {IfNode}.
+  #
+  # @see Sass::Tree
+  class IfNode < Node
+    # The conditional expression.
+    # If this is nil, this is an `@else` node, not an `@else if`.
+    #
+    # @return [Script::Expr]
+    attr_accessor :expr
+
+    # The next {IfNode} in the if-else list, or `nil`.
+    #
+    # @return [IfNode]
+    attr_accessor :else
+
+    # @param expr [Script::Expr] See \{#expr}
+    def initialize(expr)
+      @expr = expr
+      @last_else = self
+      super()
+    end
+
+    # Append an `@else` node to the end of the list.
+    #
+    # @param node [IfNode] The `@else` node to append
+    def add_else(node)
+      @last_else.else = node
+      @last_else = node
+    end
+
+    def _dump(f)
+      Marshal.dump([expr, self.else, children])
+    end
+
+    def self._load(data)
+      expr, else_, children = Marshal.load(data)
+      node = IfNode.new(expr)
+      node.else = else_
+      node.children = children
+      node.instance_variable_set('@last_else',
+        node.else ? node.else.instance_variable_get('@last_else') : node)
+      node
+    end
+  end
+end

data/lib/sass/tree/import_node.rb

@@ -0,0 +1,75 @@
+module Sass
+  module Tree
+    # A static node that wraps the {Sass::Tree} for an `@import`ed file.
+    # It doesn't have a functional purpose other than to add the `@import`ed file
+    # to the backtrace if an error occurs.
+    class ImportNode < RootNode
+      # The name of the imported file as it appears in the Sass document.
+      #
+      # @return [String]
+      attr_reader :imported_filename
+
+      # Sets the imported file.
+      attr_writer :imported_file
+
+      # @param imported_filename [String] The name of the imported file
+      def initialize(imported_filename)
+        @imported_filename = imported_filename
+        super(nil)
+      end
+
+      def invisible?; to_s.empty?; end
+
+      # Returns the imported file.
+      #
+      # @return [Sass::Engine]
+      # @raise [Sass::SyntaxError] If no file could be found to import.
+      def imported_file
+        @imported_file ||= import
+      end
+
+      # Returns whether or not this import should emit a CSS @import declaration
+      #
+      # @return [Boolean] Whether or not this is a simple CSS @import declaration.
+      def css_import?
+        if @imported_filename =~ /\.css$/
+          @imported_filename
+        elsif imported_file.is_a?(String) && imported_file =~ /\.css$/
+          imported_file
+        end
+      end
+
+      private
+
+      def import
+        paths = @options[:load_paths]
+
+        if @options[:importer]
+          f = @options[:importer].find_relative(
+            @imported_filename, @options[:filename], options_for_importer)
+          return f if f
+        end
+
+        paths.each do |p|
+          f = p.find(@imported_filename, options_for_importer)
+          return f if f
+        end
+
+        lines = ["File to import not found or unreadable: #{@imported_filename}."]
+
+        if paths.size == 1
+          lines << "Load path: #{paths.first}"
+        elsif !paths.empty?
+          lines << "Load paths:\n  #{paths.join("\n  ")}"
+        end
+        raise SyntaxError.new(lines.join("\n"))
+      rescue SyntaxError => e
+        raise SyntaxError.new(e.message, :line => line, :filename => @filename)
+      end
+
+      def options_for_importer
+        @options.merge(:_from_import_node => true)
+      end
+    end
+  end
+end

data/lib/sass/tree/keyframe_rule_node.rb

@@ -0,0 +1,15 @@
+module Sass::Tree
+  class KeyframeRuleNode < Node
+    # The text of the directive after any interpolated SassScript has been resolved.
+    # Since this is only a static node, this is the only value property.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # @param resolved_value [String] See \{#resolved_value}
+    def initialize(resolved_value)
+      @resolved_value = resolved_value
+      super()
+    end
+  end
+end

data/lib/sass/tree/media_node.rb

@@ -0,0 +1,48 @@
+module Sass::Tree
+  # A static node representing a `@media` rule.
+  # `@media` rules behave differently from other directives
+  # in that when they're nested within rules,
+  # they bubble up to top-level.
+  #
+  # @see Sass::Tree
+  class MediaNode < DirectiveNode
+    # TODO: parse and cache the query immediately if it has no dynamic elements
+
+    # The media query 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 :query
+
+    # The media query for this rule, without any unresolved interpolation. It's
+    # only set once {Tree::Visitors::Perform} has been run.
+    #
+    # @return [Sass::Media::QueryList]
+    attr_accessor :resolved_query
+
+    # @param query [Array<String, Sass::Script::Tree::Node>] See \{#query}
+    def initialize(query)
+      @query = query
+      super('')
+    end
+
+    # @see DirectiveNode#value
+    def value; raise NotImplementedError; end
+
+    # @see DirectiveNode#name
+    def name; '@media'; end
+
+    # @see DirectiveNode#resolved_value
+    def resolved_value
+      @resolved_value ||= "@media #{resolved_query.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/mixin_def_node.rb

@@ -0,0 +1,38 @@
+module Sass
+  module Tree
+    # A dynamic node representing a mixin definition.
+    #
+    # @see Sass::Tree
+    class MixinDefNode < Node
+      # The mixin name.
+      # @return [String]
+      attr_reader :name
+
+      # The arguments for the mixin.
+      # Each element is a tuple containing the variable for argument
+      # and the parse tree for the default value of the argument.
+      #
+      # @return [Array<(Script::Tree::Node, Script::Tree::Node)>]
+      attr_accessor :args
+
+      # The splat argument for this mixin, if one exists.
+      #
+      # @return [Script::Tree::Node?]
+      attr_accessor :splat
+
+      # Whether the mixin uses `@content`. Set during the nesting check phase.
+      # @return [Boolean]
+      attr_accessor :has_content
+
+      # @param name [String] The mixin name
+      # @param args [Array<(Script::Tree::Node, Script::Tree::Node)>] See \{#args}
+      # @param splat [Script::Tree::Node] See \{#splat}
+      def initialize(name, args, splat)
+        @name = name
+        @args = args
+        @splat = splat
+        super()
+      end
+    end
+  end
+end

data/lib/sass/tree/mixin_node.rb

@@ -0,0 +1,52 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A static node representing a mixin include.
+  # When in a static tree, the sole purpose is to wrap exceptions
+  # to add the mixin to the backtrace.
+  #
+  # @see Sass::Tree
+  class MixinNode < Node
+    # The name of the mixin.
+    # @return [String]
+    attr_reader :name
+
+    # The arguments to the mixin.
+    # @return [Array<Script::Tree::Node>]
+    attr_accessor :args
+
+    # A hash from keyword argument names to values.
+    # @return [Sass::Util::NormalizedMap<Script::Tree::Node>]
+    attr_accessor :keywords
+
+    # The first splat argument for this mixin, if one exists.
+    #
+    # This could be a list of positional arguments, a map of keyword
+    # arguments, or an arglist containing both.
+    #
+    # @return [Node?]
+    attr_accessor :splat
+
+    # The second splat argument for this mixin, if one exists.
+    #
+    # If this exists, it's always a map of keyword arguments, and
+    # \{#splat} is always either a list or an arglist.
+    #
+    # @return [Node?]
+    attr_accessor :kwarg_splat
+
+    # @param name [String] The name of the mixin
+    # @param args [Array<Script::Tree::Node>] See \{#args}
+    # @param splat [Script::Tree::Node] See \{#splat}
+    # @param kwarg_splat [Script::Tree::Node] See \{#kwarg_splat}
+    # @param keywords [Sass::Util::NormalizedMap<Script::Tree::Node>] See \{#keywords}
+    def initialize(name, args, keywords, splat, kwarg_splat)
+      @name = name
+      @args = args
+      @keywords = keywords
+      @splat = splat
+      @kwarg_splat = kwarg_splat
+      super()
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -0,0 +1,240 @@
+module Sass
+  # A namespace for nodes in the Sass parse tree.
+  #
+  # The Sass parse tree has three states: dynamic, static Sass, and static CSS.
+  #
+  # When it's first parsed, a Sass document is in the dynamic state.
+  # It has nodes for mixin definitions and `@for` loops and so forth,
+  # 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 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,
+  # but the structure exactly mirrors that of the generated CSS.
+  # Rules and properties can't be nested beneath one another in this state.
+  #
+  # Finally, {Tree::Visitors::ToCss} can be called on a static CSS tree
+  # to get the actual CSS code as a string.
+  module Tree
+    # The abstract superclass of all parse-tree nodes.
+    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_reader :children
+
+      # Whether or not this node has child nodes.
+      # This may be true even when \{#children} is empty,
+      # in which case this node has an empty block (e.g. `{}`).
+      #
+      # @return [Boolean]
+      attr_accessor :has_children
+
+      # The line of the document on which this node appeared.
+      #
+      # @return [Integer]
+      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]
+      attr_writer :filename
+
+      # The options hash for the node.
+      # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
+      #
+      # @return [{Symbol => Object}]
+      attr_reader :options
+
+      def initialize
+        @children = []
+        @filename = nil
+        @options = nil
+      end
+
+      # Sets the options hash for the node and all its children.
+      #
+      # @param options [{Symbol => Object}] The options
+      # @see #options
+      def options=(options)
+        Sass::Tree::Visitors::SetOptions.visit(self, options)
+      end
+
+      # @private
+      def children=(children)
+        self.has_children ||= !children.empty?
+        @children = children
+      end
+
+      # The name of the document on which this node appeared.
+      #
+      # @return [String]
+      def filename
+        @filename || (@options && @options[:filename])
+      end
+
+      # Appends a child to the node.
+      #
+      # @param child [Tree::Node, Array<Tree::Node>] The child node or nodes
+      # @raise [Sass::SyntaxError] if `child` is invalid
+      def <<(child)
+        return if child.nil?
+        if child.is_a?(Array)
+          child.each {|c| self << c}
+        else
+          self.has_children = true
+          @children << child
+        end
+      end
+
+      # Compares this node and another object (only other {Tree::Node}s will be equal).
+      # This does a structural comparison;
+      # if the contents of the nodes and all the child nodes are equivalent,
+      # then the nodes are as well.
+      #
+      # Only static nodes need to override this.
+      #
+      # @param other [Object] The object to compare with
+      # @return [Boolean] Whether or not this node and the other object
+      #   are the same
+      # @see Sass::Tree
+      def ==(other)
+        self.class == other.class && other.children == children
+      end
+
+      # True if \{#to\_s} will return `nil`;
+      # that is, if the node shouldn't be rendered.
+      # Should only be called in a static tree.
+      #
+      # @return [Boolean]
+      def invisible?; false; end
+
+      # The output style. See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
+      #
+      # @return [Symbol]
+      def style
+        @options[:style]
+      end
+
+      # Computes the CSS corresponding to this static CSS tree.
+      #
+      # @return [String] The resulting CSS
+      # @see Sass::Tree
+      def css
+        Sass::Tree::Visitors::ToCss.new.visit(self)
+      end
+
+      # Computes the CSS corresponding to this static CSS tree, along with
+      # the respective source map.
+      #
+      # @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.
+      #
+      # @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
+      # in a pre-order walk.
+      #
+      # @yield node
+      # @yieldparam node [Node] a node in the tree
+      def each
+        yield self
+        children.each {|c| c.each {|n| yield n}}
+      end
+
+      # Converts a node to Sass code that will generate it.
+      #
+      # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The Sass code corresponding to the node
+      def to_sass(options = {})
+        Sass::Tree::Visitors::Convert.visit(self, options, :sass)
+      end
+
+      # Converts a node to SCSS code that will generate it.
+      #
+      # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The Sass code corresponding to the node
+      def to_scss(options = {})
+        Sass::Tree::Visitors::Convert.visit(self, options, :scss)
+      end
+
+      # Return a deep clone of this node.
+      # The child nodes are cloned, but options are not.
+      #
+      # @return [Node]
+      def deep_copy
+        Sass::Tree::Visitors::DeepCopy.visit(self)
+      end
+
+      # Whether or not this node bubbles up through RuleNodes.
+      #
+      # @return [Boolean]
+      def bubbles?
+        false
+      end
+
+      protected
+
+      # @see Sass::Shared.balance
+      # @raise [Sass::SyntaxError] if the brackets aren't balanced
+      def balance(*args)
+        res = Sass::Shared.balance(*args)
+        return res if res
+        raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
+      end
+    end
+  end
+end