sass4 4.0.0

data/lib/sass/script/tree/map_literal.rb

@@ -0,0 +1,64 @@
+module Sass::Script::Tree
+  # A class representing a map literal. When resolved, this returns a
+  # {Sass::Script::Node::Map}.
+  class MapLiteral < Node
+    # The key/value pairs that make up this map node. This isn't a Hash so that
+    # we can detect key collisions once all the keys have been performed.
+    #
+    # @return [Array<(Node, Node)>]
+    attr_reader :pairs
+
+    # Creates a new map literal.
+    #
+    # @param pairs [Array<(Node, Node)>] See \{#pairs}
+    def initialize(pairs)
+      @pairs = pairs
+    end
+
+    # @see Node#children
+    def children
+      @pairs.flatten
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      return "()" if pairs.empty?
+
+      to_sass = lambda do |value|
+        if value.is_a?(ListLiteral) && value.separator == :comma
+          "(#{value.to_sass(opts)})"
+        else
+          value.to_sass(opts)
+        end
+      end
+
+      "(" + pairs.map {|(k, v)| "#{to_sass[k]}: #{to_sass[v]}"}.join(', ') + ")"
+    end
+    alias_method :inspect, :to_sass
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@pairs',
+        pairs.map {|(k, v)| [k.deep_copy, v.deep_copy]})
+      node
+    end
+
+    protected
+
+    # @see Node#_perform
+    def _perform(environment)
+      keys = Set.new
+      map = Sass::Script::Value::Map.new(Hash[pairs.map do |(k, v)|
+        k, v = k.perform(environment), v.perform(environment)
+        if keys.include?(k)
+          raise Sass::SyntaxError.new("Duplicate key #{k.inspect} in map #{to_sass}.")
+        end
+        keys << k
+        [k, v]
+      end])
+      map.options = options
+      map
+    end
+  end
+end

data/lib/sass/script/tree/node.rb

@@ -0,0 +1,119 @@
+module Sass::Script::Tree
+  # The abstract superclass for SassScript parse tree nodes.
+  #
+  # Use \{#perform} to evaluate a parse tree.
+  class Node
+    # The options hash for this node.
+    #
+    # @return [{Symbol => Object}]
+    attr_reader :options
+
+    # 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 file name of the document on which this node appeared.
+    #
+    # @return [String]
+    attr_accessor :filename
+
+    # Sets the options hash for this node,
+    # as well as for all child nodes.
+    # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
+    #
+    # @param options [{Symbol => Object}] The options
+    def options=(options)
+      @options = options
+      children.each do |c|
+        if c.is_a? Hash
+          c.values.each {|v| v.options = options}
+        else
+          c.options = options
+        end
+      end
+    end
+
+    # Evaluates the node.
+    #
+    # \{#perform} shouldn't be overridden directly;
+    # instead, override \{#\_perform}.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the SassScript
+    def perform(environment)
+      _perform(environment)
+    rescue Sass::SyntaxError => e
+      e.modify_backtrace(:line => line)
+      raise e
+    end
+
+    # Returns all child nodes of this node.
+    #
+    # @return [Array<Node>]
+    def children
+      Sass::Util.abstract(self)
+    end
+
+    # Returns the text of this SassScript expression.
+    #
+    # @options opts :quote [String]
+    #   The preferred quote style for quoted strings. If `:none`, strings are
+    #   always emitted unquoted.
+    #
+    # @return [String]
+    def to_sass(opts = {})
+      Sass::Util.abstract(self)
+    end
+
+    # Returns a deep clone of this node.
+    # The child nodes are cloned, but options are not.
+    #
+    # @return [Node]
+    def deep_copy
+      Sass::Util.abstract(self)
+    end
+
+    # Forces any division operations with number literals in this expression to
+    # do real division, rather than returning strings.
+    def force_division!
+      children.each {|c| c.force_division!}
+    end
+
+    protected
+
+    # Converts underscores to dashes if the :dasherize option is set.
+    def dasherize(s, opts)
+      if opts[:dasherize]
+        s.tr('_', '-')
+      else
+        s
+      end
+    end
+
+    # Evaluates this node.
+    # Note that all {Sass::Script::Value} objects created within this method
+    # should have their \{#options} attribute set, probably via \{#opts}.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the SassScript
+    # @see #perform
+    def _perform(environment)
+      Sass::Util.abstract(self)
+    end
+
+    # Sets the \{#options} field on the given value and returns it.
+    #
+    # @param value [Sass::Script::Value]
+    # @return [Sass::Script::Value]
+    def opts(value)
+      value.options = options
+      value
+    end
+  end
+end

data/lib/sass/script/tree/operation.rb

@@ -0,0 +1,149 @@
+module Sass::Script::Tree
+  # A SassScript parse node representing a binary operation,
+  # such as `$a + $b` or `"foo" + 1`.
+  class Operation < Node
+    @@color_arithmetic_deprecation = Sass::Deprecation.new
+    @@unitless_equals_deprecation = Sass::Deprecation.new
+
+    attr_reader :operand1
+    attr_reader :operand2
+    attr_reader :operator
+
+    # @param operand1 [Sass::Script::Tree::Node] The parse-tree node
+    #   for the right-hand side of the operator
+    # @param operand2 [Sass::Script::Tree::Node] The parse-tree node
+    #   for the left-hand side of the operator
+    # @param operator [Symbol] The operator to perform.
+    #   This should be one of the binary operator names in {Sass::Script::Lexer::OPERATORS}
+    def initialize(operand1, operand2, operator)
+      @operand1 = operand1
+      @operand2 = operand2
+      @operator = operator
+      super()
+    end
+
+    # @return [String] A human-readable s-expression representation of the operation
+    def inspect
+      "(#{@operator.inspect} #{@operand1.inspect} #{@operand2.inspect})"
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      o1 = operand_to_sass @operand1, :left, opts
+      o2 = operand_to_sass @operand2, :right, opts
+      sep =
+        case @operator
+        when :comma; ", "
+        when :space; " "
+        else; " #{Sass::Script::Lexer::OPERATORS_REVERSE[@operator]} "
+        end
+      "#{o1}#{sep}#{o2}"
+    end
+
+    # Returns the operands for this operation.
+    #
+    # @return [Array<Node>]
+    # @see Node#children
+    def children
+      [@operand1, @operand2]
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@operand1', @operand1.deep_copy)
+      node.instance_variable_set('@operand2', @operand2.deep_copy)
+      node
+    end
+
+    protected
+
+    # Evaluates the operation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the operation
+    # @raise [Sass::SyntaxError] if the operation is undefined for the operands
+    def _perform(environment)
+      value1 = @operand1.perform(environment)
+
+      # Special-case :and and :or to support short-circuiting.
+      if @operator == :and
+        return value1.to_bool ? @operand2.perform(environment) : value1
+      elsif @operator == :or
+        return value1.to_bool ? value1 : @operand2.perform(environment)
+      end
+
+      value2 = @operand2.perform(environment)
+
+      if (value1.is_a?(Sass::Script::Value::Null) || value2.is_a?(Sass::Script::Value::Null)) &&
+          @operator != :eq && @operator != :neq
+        raise Sass::SyntaxError.new(
+          "Invalid null operation: \"#{value1.inspect} #{@operator} #{value2.inspect}\".")
+      end
+
+      begin
+        result = opts(value1.send(@operator, value2))
+      rescue NoMethodError => e
+        raise e unless e.name.to_s == @operator.to_s
+        raise Sass::SyntaxError.new("Undefined operation: \"#{value1} #{@operator} #{value2}\".")
+      end
+
+      warn_for_color_arithmetic(value1, value2)
+      warn_for_unitless_equals(value1, value2, result)
+
+      result
+    end
+
+    private
+
+    def warn_for_color_arithmetic(value1, value2)
+      return unless @operator == :plus || @operator == :times || @operator == :minus ||
+                    @operator == :div || @operator == :mod
+
+      if value1.is_a?(Sass::Script::Value::Number)
+        return unless value2.is_a?(Sass::Script::Value::Color)
+      elsif value1.is_a?(Sass::Script::Value::Color)
+        return unless value2.is_a?(Sass::Script::Value::Color) || value2.is_a?(Sass::Script::Value::Number)
+      else
+        return
+      end
+
+      @@color_arithmetic_deprecation.warn(filename, line, <<WARNING)
+The operation `#{value1} #{@operator} #{value2}` is deprecated and will be an error in future versions.
+Consider using Sass's color functions instead.
+https://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions
+WARNING
+    end
+
+    def warn_for_unitless_equals(value1, value2, result)
+      return unless @operator == :eq || @operator == :neq
+      return unless value1.is_a?(Sass::Script::Value::Number)
+      return unless value2.is_a?(Sass::Script::Value::Number)
+      return unless value1.unitless? != value2.unitless?
+      return unless result == (if @operator == :eq
+                                 Sass::Script::Value::Bool::TRUE
+                               else
+                                 Sass::Script::Value::Bool::FALSE
+                               end)
+
+      operation = "#{value1.to_sass} #{@operator == :eq ? '==' : '!='} #{value2.to_sass}"
+      future_value = @operator == :neq
+      @@unitless_equals_deprecation.warn(filename, line, <<WARNING)
+The result of `#{operation}` will be `#{future_value}` in future releases of Sass.
+Unitless numbers will no longer be equal to the same numbers with units.
+WARNING
+    end
+
+    def operand_to_sass(op, side, opts)
+      return "(#{op.to_sass(opts)})" if op.is_a?(Sass::Script::Tree::ListLiteral)
+      return op.to_sass(opts) unless op.is_a?(Operation)
+
+      pred = Sass::Script::Parser.precedence_of(@operator)
+      sub_pred = Sass::Script::Parser.precedence_of(op.operator)
+      assoc = Sass::Script::Parser.associative?(@operator)
+      return "(#{op.to_sass(opts)})" if sub_pred < pred ||
+        (side == :right && sub_pred == pred && !assoc)
+      op.to_sass(opts)
+    end
+  end
+end

data/lib/sass/script/tree/selector.rb

@@ -0,0 +1,26 @@
+module Sass::Script::Tree
+  # A SassScript node that will resolve to the current selector.
+  class Selector < Node
+    def initialize; end
+
+    def children
+      []
+    end
+
+    def to_sass(opts = {})
+      '&'
+    end
+
+    def deep_copy
+      dup
+    end
+
+    protected
+
+    def _perform(environment)
+      selector = environment.selector
+      return opts(Sass::Script::Value::Null.new) unless selector
+      opts(selector.to_sass_script)
+    end
+  end
+end

data/lib/sass/script/tree/string_interpolation.rb

@@ -0,0 +1,125 @@
+module Sass::Script::Tree
+  # A SassScript object representing `#{}` interpolation within a string.
+  #
+  # @see Interpolation
+  class StringInterpolation < Node
+    # @return [Literal] The string literal before this interpolation.
+    attr_reader :before
+
+    # @return [Node] The SassScript within the interpolation
+    attr_reader :mid
+
+    # @return [StringInterpolation, Literal]
+    #     The string literal or string interpolation before this interpolation.
+    attr_reader :after
+
+    # Whether this is a CSS string or a CSS identifier. The difference is that
+    # strings are written with double-quotes, while identifiers aren't.
+    #
+    # String interpolations are only ever identifiers if they're quote-like
+    # functions such as `url()`.
+    #
+    # @return [Symbol] `:string` or `:identifier`
+    def type
+      @before.value.type
+    end
+
+    # Returns the quote character that should be used to wrap a Sass
+    # representation of this interpolation.
+    def quote
+      quote_for(self) || '"'
+    end
+
+    # Interpolation in a string is of the form `"before #{mid} after"`,
+    # where `before` and `after` may include more interpolation.
+    #
+    # @param before [StringInterpolation, Literal] See {StringInterpolation#before}
+    # @param mid [Node] See {StringInterpolation#mid}
+    # @param after [Literal] See {StringInterpolation#after}
+    def initialize(before, mid, after)
+      @before = before
+      @mid = mid
+      @after = after
+    end
+
+    # @return [String] A human-readable s-expression representation of the interpolation
+    def inspect
+      "(string_interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      quote = type == :string ? opts[:quote] || quote_for(self) || '"' : :none
+      opts = opts.merge(:quote => quote)
+
+      res = ""
+      res << quote if quote != :none
+      res << _to_sass(before, opts)
+      res << '#{' << @mid.to_sass(opts.merge(:quote => nil)) << '}'
+      res << _to_sass(after, opts)
+      res << quote if quote != :none
+      res
+    end
+
+    # Returns the three components of the interpolation, `before`, `mid`, and `after`.
+    #
+    # @return [Array<Node>]
+    # @see #initialize
+    # @see Node#children
+    def children
+      [@before, @mid, @after].compact
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@before', @before.deep_copy) if @before
+      node.instance_variable_set('@mid', @mid.deep_copy)
+      node.instance_variable_set('@after', @after.deep_copy) if @after
+      node
+    end
+
+    protected
+
+    # Evaluates the interpolation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::Value::String]
+    #   The SassScript string that is the value of the interpolation
+    def _perform(environment)
+      res = ""
+      before = @before.perform(environment)
+      res << before.value
+      mid = @mid.perform(environment)
+      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s(:quote => :none))
+      res << @after.perform(environment).value
+      opts(Sass::Script::Value::String.new(res, before.type))
+    end
+
+    private
+
+    def _to_sass(string_or_interp, opts)
+      result = string_or_interp.to_sass(opts)
+      opts[:quote] == :none ? result : result.slice(1...-1)
+    end
+
+    def quote_for(string_or_interp)
+      if string_or_interp.is_a?(Sass::Script::Tree::Literal)
+        return nil if string_or_interp.value.value.empty?
+        return '"' if string_or_interp.value.value.include?("'")
+        return "'" if string_or_interp.value.value.include?('"')
+        return nil
+      end
+
+      # Double-quotes take precedence over single quotes.
+      before_quote = quote_for(string_or_interp.before)
+      return '"' if before_quote == '"'
+      after_quote = quote_for(string_or_interp.after)
+      return '"' if after_quote == '"'
+
+      # Returns "'" if either or both insist on single quotes, and nil
+      # otherwise.
+      before_quote || after_quote
+    end
+  end
+end

data/lib/sass/script/tree/unary_operation.rb

@@ -0,0 +1,69 @@
+module Sass::Script::Tree
+  # A SassScript parse node representing a unary operation,
+  # such as `-$b` or `not true`.
+  #
+  # Currently only `-`, `/`, and `not` are unary operators.
+  class UnaryOperation < Node
+    # @return [Symbol] The operation to perform
+    attr_reader :operator
+
+    # @return [Script::Node] The parse-tree node for the object of the operator
+    attr_reader :operand
+
+    # @param operand [Script::Node] See \{#operand}
+    # @param operator [Symbol] See \{#operator}
+    def initialize(operand, operator)
+      @operand = operand
+      @operator = operator
+      super()
+    end
+
+    # @return [String] A human-readable s-expression representation of the operation
+    def inspect
+      "(#{@operator.inspect} #{@operand.inspect})"
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      operand = @operand.to_sass(opts)
+      if @operand.is_a?(Operation) ||
+          (@operator == :minus &&
+           (operand =~ Sass::SCSS::RX::IDENT) == 0)
+        operand = "(#{@operand.to_sass(opts)})"
+      end
+      op = Sass::Script::Lexer::OPERATORS_REVERSE[@operator]
+      op + (op =~ /[a-z]/ ? " " : "") + operand
+    end
+
+    # Returns the operand of the operation.
+    #
+    # @return [Array<Node>]
+    # @see Node#children
+    def children
+      [@operand]
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@operand', @operand.deep_copy)
+      node
+    end
+
+    protected
+
+    # Evaluates the operation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the operation
+    # @raise [Sass::SyntaxError] if the operation is undefined for the operand
+    def _perform(environment)
+      operator = "unary_#{@operator}"
+      value = @operand.perform(environment)
+      value.send(operator)
+    rescue NoMethodError => e
+      raise e unless e.name.to_s == operator.to_s
+      raise Sass::SyntaxError.new("Undefined unary operation: \"#{@operator} #{value}\".")
+    end
+  end
+end

data/lib/sass/script/tree/variable.rb

@@ -0,0 +1,57 @@
+module Sass::Script::Tree
+  # A SassScript parse node representing a variable.
+  class Variable < Node
+    # The name of the variable.
+    #
+    # @return [String]
+    attr_reader :name
+
+    # The underscored name of the variable.
+    #
+    # @return [String]
+    attr_reader :underscored_name
+
+    # @param name [String] See \{#name}
+    def initialize(name)
+      @name = name
+      @underscored_name = name.tr("-", "_")
+      super()
+    end
+
+    # @return [String] A string representation of the variable
+    def inspect(opts = {})
+      "$#{dasherize(name, opts)}"
+    end
+    alias_method :to_sass, :inspect
+
+    # Returns an empty array.
+    #
+    # @return [Array<Node>] empty
+    # @see Node#children
+    def children
+      []
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      dup
+    end
+
+    protected
+
+    # Evaluates the variable.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the variable
+    # @raise [Sass::SyntaxError] if the variable is undefined
+    def _perform(environment)
+      val = environment.var(name)
+      raise Sass::SyntaxError.new("Undefined variable: \"$#{name}\".") unless val
+      if val.is_a?(Sass::Script::Value::Number) && val.original
+        val = val.dup
+        val.original = nil
+      end
+      val
+    end
+  end
+end

data/lib/sass/script/tree.rb

@@ -0,0 +1,16 @@
+# The module containing nodes in the SassScript parse tree. These nodes are
+# all subclasses of {Sass::Script::Tree::Node}.
+module Sass::Script::Tree
+end
+
+require 'sass/script/tree/node'
+require 'sass/script/tree/variable'
+require 'sass/script/tree/funcall'
+require 'sass/script/tree/operation'
+require 'sass/script/tree/unary_operation'
+require 'sass/script/tree/interpolation'
+require 'sass/script/tree/string_interpolation'
+require 'sass/script/tree/literal'
+require 'sass/script/tree/list_literal'
+require 'sass/script/tree/map_literal'
+require 'sass/script/tree/selector'

data/lib/sass/script/value/arg_list.rb

@@ -0,0 +1,36 @@
+module Sass::Script::Value
+  # A SassScript object representing a variable argument list. This works just
+  # like a normal list, but can also contain keyword arguments.
+  #
+  # The keyword arguments attached to this list are unused except when this is
+  # passed as a glob argument to a function or mixin.
+  class ArgList < List
+    # Whether \{#keywords} has been accessed. If so, we assume that all keywords
+    # were valid for the function that created this ArgList.
+    #
+    # @return [Boolean]
+    attr_accessor :keywords_accessed
+
+    # Creates a new argument list.
+    #
+    # @param value [Array<Value>] See \{List#value}.
+    # @param keywords [Hash<String, Value>, NormalizedMap<Value>] See \{#keywords}
+    # @param separator [String] See \{List#separator}.
+    def initialize(value, keywords, separator)
+      super(value, separator: separator)
+      if keywords.is_a?(Sass::Util::NormalizedMap)
+        @keywords = keywords
+      else
+        @keywords = Sass::Util::NormalizedMap.new(keywords)
+      end
+    end
+
+    # The keyword arguments attached to this list.
+    #
+    # @return [NormalizedMap<Value>]
+    def keywords
+      @keywords_accessed = true
+      @keywords
+    end
+  end
+end