sass4 4.0.0

data/lib/sass/stack.rb

@@ -0,0 +1,140 @@
+module Sass
+  # A class representing the stack when compiling a Sass file.
+  class Stack
+    # TODO: use this to generate stack information for Sass::SyntaxErrors.
+
+    # A single stack frame.
+    class Frame
+      # The filename of the file in which this stack frame was created.
+      #
+      # @return [String]
+      attr_reader :filename
+
+      # The line number on which this stack frame was created.
+      #
+      # @return [String]
+      attr_reader :line
+
+      # The type of this stack frame. This can be `:import`, `:mixin`, or
+      # `:base`.
+      #
+      # `:base` indicates that this is the bottom-most frame, meaning that it
+      # represents a single line of code rather than a nested context. The stack
+      # will only ever have one base frame, and it will always be the most
+      # deeply-nested frame.
+      #
+      # @return [Symbol?]
+      attr_reader :type
+
+      # The name of the stack frame. For mixin frames, this is the mixin name;
+      # otherwise, it's `nil`.
+      #
+      # @return [String?]
+      attr_reader :name
+
+      def initialize(filename, line, type, name = nil)
+        @filename = filename
+        @line = line
+        @type = type
+        @name = name
+      end
+
+      # Whether this frame represents an import.
+      #
+      # @return [Boolean]
+      def is_import?
+        type == :import
+      end
+
+      # Whether this frame represents a mixin.
+      #
+      # @return [Boolean]
+      def is_mixin?
+        type == :mixin
+      end
+
+      # Whether this is the base frame.
+      #
+      # @return [Boolean]
+      def is_base?
+        type == :base
+      end
+    end
+
+    # The stack frames. The last frame is the most deeply-nested.
+    #
+    # @return [Array<Frame>]
+    attr_reader :frames
+
+    def initialize
+      @frames = []
+    end
+
+    # Pushes a base frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_base(filename, line)
+      with_frame(filename, line, :base) {yield}
+    end
+
+    # Pushes an import frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_import(filename, line)
+      with_frame(filename, line, :import) {yield}
+    end
+
+    # Pushes a mixin frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_mixin(filename, line, name)
+      with_frame(filename, line, :mixin, name) {yield}
+    end
+
+    # Pushes a function frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_function(filename, line, name)
+      with_frame(filename, line, :function, name) {yield}
+    end
+
+    # Pushes a function frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_directive(filename, line, name)
+      with_frame(filename, line, :directive, name) {yield}
+    end
+
+    def to_s
+      (frames.reverse + [nil]).each_cons(2).each_with_index.
+          map do |(frame, caller), i|
+        "#{i == 0 ? 'on' : 'from'} line #{frame.line}" +
+          " of #{frame.filename || 'an unknown file'}" +
+          (caller && caller.name ? ", in `#{caller.name}'" : "")
+      end.join("\n")
+    end
+
+    private
+
+    def with_frame(filename, line, type, name = nil)
+      @frames.pop if @frames.last && @frames.last.type == :base
+      @frames.push(Frame.new(filename, line, type, name))
+      yield
+    ensure
+      @frames.pop unless type == :base && @frames.last && @frames.last.type != :base
+    end
+  end
+end

data/lib/sass/supports.rb

@@ -0,0 +1,225 @@
+# A namespace for the `@supports` condition parse tree.
+module Sass::Supports
+  # The abstract superclass of all Supports conditions.
+  class Condition
+    # Runs the SassScript in the supports condition.
+    #
+    # @param environment [Sass::Environment] The environment in which to run the script.
+    def perform(environment); Sass::Util.abstract(self); end
+
+    # Returns the CSS for this condition.
+    #
+    # @return [String]
+    def to_css; Sass::Util.abstract(self); end
+
+    # Returns the Sass/CSS code for this condition.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options); Sass::Util.abstract(self); end
+
+    # Returns a deep copy of this condition and all its children.
+    #
+    # @return [Condition]
+    def deep_copy; Sass::Util.abstract(self); end
+
+    # Sets the options hash for the script nodes in the supports condition.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options); Sass::Util.abstract(self); end
+  end
+
+  # An operator condition (e.g. `CONDITION1 and CONDITION2`).
+  class Operator < Condition
+    # The left-hand condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :left
+
+    # The right-hand condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :right
+
+    # The operator ("and" or "or").
+    #
+    # @return [String]
+    attr_accessor :op
+
+    def initialize(left, right, op)
+      @left = left
+      @right = right
+      @op = op
+    end
+
+    def perform(env)
+      @left.perform(env)
+      @right.perform(env)
+    end
+
+    def to_css
+      "#{parens @left, @left.to_css} #{op} #{parens @right, @right.to_css}"
+    end
+
+    def to_src(options)
+      "#{parens @left, @left.to_src(options)} #{op} #{parens @right, @right.to_src(options)}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.left = @left.deep_copy
+      copy.right = @right.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @left.options = options
+      @right.options = options
+    end
+
+    private
+
+    def parens(condition, str)
+      if condition.is_a?(Negation) || (condition.is_a?(Operator) && condition.op != op)
+        return "(#{str})"
+      else
+        return str
+      end
+    end
+  end
+
+  # A negation condition (`not CONDITION`).
+  class Negation < Condition
+    # The condition being negated.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :condition
+
+    def initialize(condition)
+      @condition = condition
+    end
+
+    def perform(env)
+      @condition.perform(env)
+    end
+
+    def to_css
+      "not #{parens @condition.to_css}"
+    end
+
+    def to_src(options)
+      "not #{parens @condition.to_src(options)}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.condition = condition.deep_copy
+      copy
+    end
+
+    def options=(options)
+      condition.options = options
+    end
+
+    private
+
+    def parens(str)
+      return "(#{str})" if @condition.is_a?(Negation) || @condition.is_a?(Operator)
+      str
+    end
+  end
+
+  # A declaration condition (e.g. `(feature: value)`).
+  class Declaration < Condition
+    # @return [Sass::Script::Tree::Node] The feature name.
+    attr_accessor :name
+
+    # @!attribute resolved_name
+    #   The name of the feature after any SassScript has been resolved.
+    #   Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    #   @return [String]
+    attr_accessor :resolved_name
+
+    # The feature value.
+    #
+    # @return [Sass::Script::Tree::Node]
+    attr_accessor :value
+
+    # The value of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def perform(env)
+      @resolved_name = name.perform(env)
+      @resolved_value = value.perform(env)
+    end
+
+    def to_css
+      "(#{@resolved_name}: #{@resolved_value})"
+    end
+
+    def to_src(options)
+      "(#{@name.to_sass(options)}: #{@value.to_sass(options)})"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.name = @name.deep_copy
+      copy.value = @value.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @name.options = options
+      @value.options = options
+    end
+  end
+
+  # An interpolation condition (e.g. `#{$var}`).
+  class Interpolation < Condition
+    # The SassScript expression in the interpolation.
+    #
+    # @return [Sass::Script::Tree::Node]
+    attr_accessor :value
+
+    # The value of the expression after it's been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def perform(env)
+      @resolved_value = value.perform(env).to_s(:quote => :none)
+    end
+
+    def to_css
+      @resolved_value
+    end
+
+    def to_src(options)
+      @value.to_sass(options)
+    end
+
+    def deep_copy
+      copy = dup
+      copy.value = @value.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @value.options = options
+    end
+  end
+end

data/lib/sass/tree/at_root_node.rb

@@ -0,0 +1,83 @@
+module Sass
+  module Tree
+    # A dynamic node representing an `@at-root` directive.
+    #
+    # An `@at-root` directive with a selector is converted to an \{AtRootNode}
+    # containing a \{RuleNode} at parse time.
+    #
+    # @see Sass::Tree
+    class AtRootNode < Node
+      # The query for this node (e.g. `(without: media)`),
+      # interspersed with {Sass::Script::Tree::Node}s representing
+      # `#{}`-interpolation. Any adjacent strings will be merged
+      # together.
+      #
+      # This will be nil if the directive didn't have a query. In this
+      # case, {#resolved\_type} will automatically be set to
+      # `:without` and {#resolved\_rule} will automatically be set to `["rule"]`.
+      #
+      # @return [Array<String, Sass::Script::Tree::Node>]
+      attr_accessor :query
+
+      # The resolved type of this directive. `:with` or `:without`.
+      #
+      # @return [Symbol]
+      attr_accessor :resolved_type
+
+      # The resolved value of this directive -- a list of directives
+      # to either include or exclude.
+      #
+      # @return [Array<String>]
+      attr_accessor :resolved_value
+
+      # The number of additional tabs that the contents of this node
+      # should be indented.
+      #
+      # @return [Number]
+      attr_accessor :tabs
+
+      # Whether the last child of this node should be considered the
+      # end of a group.
+      #
+      # @return [Boolean]
+      attr_accessor :group_end
+
+      def initialize(query = nil)
+        super()
+        @query = Sass::Util.strip_string_array(Sass::Util.merge_adjacent_strings(query)) if query
+        @tabs = 0
+      end
+
+      # Returns whether or not the given directive is excluded by this
+      # node. `directive` may be "rule", which indicates whether
+      # normal CSS rules should be excluded.
+      #
+      # @param directive [String]
+      # @return [Boolean]
+      def exclude?(directive)
+        if resolved_type == :with
+          return false if resolved_value.include?('all')
+          !resolved_value.include?(directive)
+        else # resolved_type == :without
+          return true if resolved_value.include?('all')
+          resolved_value.include?(directive)
+        end
+      end
+
+      # Returns whether the given node is excluded by this node.
+      #
+      # @param node [Sass::Tree::Node]
+      # @return [Boolean]
+      def exclude_node?(node)
+        return exclude?(node.name.gsub(/^@/, '')) if node.is_a?(Sass::Tree::DirectiveNode)
+        return exclude?('keyframes') if node.is_a?(Sass::Tree::KeyframeRuleNode)
+        exclude?('rule') && node.is_a?(Sass::Tree::RuleNode)
+      end
+
+      # @see Node#bubbles?
+      def bubbles?
+        true
+      end
+    end
+  end
+end

data/lib/sass/tree/charset_node.rb

@@ -0,0 +1,22 @@
+module Sass::Tree
+  # A static node representing an unprocessed Sass `@charset` directive.
+  #
+  # @see Sass::Tree
+  class CharsetNode < Node
+    # The name of the charset.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # @param name [String] see \{#name}
+    def initialize(name)
+      @name = name
+      super()
+    end
+
+    # @see Node#invisible?
+    def invisible?
+      true
+    end
+  end
+end

data/lib/sass/tree/comment_node.rb

@@ -0,0 +1,82 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A static node representing a Sass comment (silent or loud).
+  #
+  # @see Sass::Tree
+  class CommentNode < Node
+    # The text of the comment, not including `/*` and `*/`.
+    # Interspersed with {Sass::Script::Tree::Node}s representing `#{}`-interpolation
+    # if this is a loud comment.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :value
+
+    # The text of the comment
+    # after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # The type of the comment. `:silent` means it's never output to CSS,
+    # `:normal` means it's output in every compile mode except `:compressed`,
+    # and `:loud` means it's output even in `:compressed`.
+    #
+    # @return [Symbol]
+    attr_accessor :type
+
+    # @param value [Array<String, Sass::Script::Tree::Node>] See \{#value}
+    # @param type [Symbol] See \{#type}
+    def initialize(value, type)
+      @value = Sass::Util.with_extracted_values(value) {|str| normalize_indentation str}
+      @type = type
+      super()
+    end
+
+    # Compares the contents of two comments.
+    #
+    # @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 && value == other.value && type == other.type
+    end
+
+    # Returns `true` if this is a silent comment
+    # or the current style doesn't render comments.
+    #
+    # Comments starting with ! are never invisible (and the ! is removed from the output.)
+    #
+    # @return [Boolean]
+    def invisible?
+      case @type
+      when :loud; false
+      when :silent; true
+      else; style == :compressed
+      end
+    end
+
+    # Returns the number of lines in the comment.
+    #
+    # @return [Integer]
+    def lines
+      @value.inject(0) do |s, e|
+        next s + e.count("\n") if e.is_a?(String)
+        next s
+      end
+    end
+
+    private
+
+    def normalize_indentation(str)
+      ind = str.split("\n").inject(str[/^[ \t]*/].split("")) do |pre, line|
+        line[/^[ \t]*/].split("").zip(pre).inject([]) do |arr, (a, b)|
+          break arr if a != b
+          arr << a
+        end
+      end.join
+      str.gsub(/^#{ind}/, '')
+    end
+  end
+end

data/lib/sass/tree/content_node.rb

@@ -0,0 +1,9 @@
+module Sass
+  module Tree
+    # A node representing the placement within a mixin of the include statement's content.
+    #
+    # @see Sass::Tree
+    class ContentNode < Node
+    end
+  end
+end

data/lib/sass/tree/css_import_node.rb

@@ -0,0 +1,68 @@
+module Sass::Tree
+  # A node representing an `@import` rule that's importing plain CSS.
+  #
+  # @see Sass::Tree
+  class CssImportNode < DirectiveNode
+    # The URI being imported, either as a plain string or an interpolated
+    # script string.
+    #
+    # @return [String, Sass::Script::Tree::Node]
+    attr_accessor :uri
+
+    # The text of the URI being imported after any interpolated SassScript has
+    # been resolved. Only set once {Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_uri
+
+    # The supports condition for this import.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :supports_condition
+
+    # 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 uri [String, Sass::Script::Tree::Node] See \{#uri}
+    # @param query [Array<String, Sass::Script::Tree::Node>] See \{#query}
+    # @param supports_condition [Sass::Supports::Condition] See \{#supports_condition}
+    def initialize(uri, query = [], supports_condition = nil)
+      @uri = uri
+      @query = query
+      @supports_condition = supports_condition
+      super('')
+    end
+
+    # @param uri [String] See \{#resolved_uri}
+    # @return [CssImportNode]
+    def self.resolved(uri)
+      node = new(uri)
+      node.resolved_uri = uri
+      node
+    end
+
+    # @see DirectiveNode#value
+    def value; raise NotImplementedError; end
+
+    # @see DirectiveNode#resolved_value
+    def resolved_value
+      @resolved_value ||=
+        begin
+          str = "@import #{resolved_uri}"
+          str << " supports(#{supports_condition.to_css})" if supports_condition
+          str << " #{resolved_query.to_css}" if resolved_query
+          str
+        end
+    end
+  end
+end

data/lib/sass/tree/debug_node.rb

@@ -0,0 +1,18 @@
+module Sass
+  module Tree
+    # A dynamic node representing a Sass `@debug` statement.
+    #
+    # @see Sass::Tree
+    class DebugNode < 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/directive_node.rb

@@ -0,0 +1,59 @@
+module Sass::Tree
+  # A static node representing an unprocessed Sass `@`-directive.
+  # Directives known to Sass, like `@for` and `@debug`,
+  # are handled by their own nodes;
+  # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
+  #
+  # `@import` and `@charset` are special cases;
+  # they become {ImportNode}s and {CharsetNode}s, respectively.
+  #
+  # @see Sass::Tree
+  class DirectiveNode < Node
+    # The text of the directive, `@` and all, with interpolation included.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :value
+
+    # The text of the directive after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # @see RuleNode#tabs
+    attr_accessor :tabs
+
+    # @see RuleNode#group_end
+    attr_accessor :group_end
+
+    # @param value [Array<String, Sass::Script::Tree::Node>] See \{#value}
+    def initialize(value)
+      @value = value
+      @tabs = 0
+      super()
+    end
+
+    # @param value [String] See \{#resolved_value}
+    # @return [DirectiveNode]
+    def self.resolved(value)
+      node = new([value])
+      node.resolved_value = value
+      node
+    end
+
+    # @return [String] The name of the directive, including `@`.
+    def name
+      @name ||= value.first.gsub(/ .*$/, '')
+    end
+
+    # Strips out any vendor prefixes and downcases the directive name.
+    # @return [String] The normalized name of the directive.
+    def normalized_name
+      @normalized_name ||= name.gsub(/^(@)(?:-[a-zA-Z0-9]+-)?/, '\1').downcase
+    end
+
+    def bubbles?
+      has_children
+    end
+  end
+end