sass 3.1.0 → 3.3.0

data/lib/sass/script/{operation.rb → tree/operation.rb}

@@ -1,13 +1,4 @@
-require 'set'
-require 'sass/script/string'
-require 'sass/script/number'
-require 'sass/script/color'
-require 'sass/script/functions'
-require 'sass/script/unary_operation'
-require 'sass/script/interpolation'
-require 'sass/script/string_interpolation'
-
-module Sass::Script
+module Sass::Script::Tree
   # A SassScript parse node representing a binary operation,
   # such as `$a + $b` or `"foo" + 1`.
   class Operation < Node
@@ -15,12 +6,12 @@ module Sass::Script
     attr_reader :operand2
     attr_reader :operator
 
-    # @param operand1 [Script::Node] The parse-tree node
+    # @param operand1 [Sass::Script::Tree::Node] The parse-tree node
     #   for the right-hand side of the operator
-    # @param operand2 [Script::Node] The parse-tree node
+    # @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 {Lexer::OPERATORS}
+    #   This should be one of the binary operator names in {Sass::Script::Lexer::OPERATORS}
     def initialize(operand1, operand2, operator)
       @operand1 = operand1
       @operand2 = operand2
@@ -35,14 +26,13 @@ module Sass::Script
 
     # @see Node#to_sass
     def to_sass(opts = {})
-      pred = Sass::Script::Parser.precedence_of(@operator)
       o1 = operand_to_sass @operand1, :left, opts
       o2 = operand_to_sass @operand2, :right, opts
       sep =
         case @operator
         when :comma; ", "
         when :space; " "
-        else; " #{Lexer::OPERATORS_REVERSE[@operator]} "
+        else; " #{Sass::Script::Lexer::OPERATORS_REVERSE[@operator]} "
         end
       "#{o1}#{sep}#{o2}"
     end
@@ -55,29 +45,51 @@ module Sass::Script
       [@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 [Literal] The SassScript object that is the value of the operation
+    # @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)
-      literal1 = @operand1.perform(environment)
-      literal2 = @operand2.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
-        opts(literal1.send(@operator, literal2))
+        opts(value1.send(@operator, value2))
       rescue NoMethodError => e
         raise e unless e.name.to_s == @operator.to_s
-        raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\".")
+        raise Sass::SyntaxError.new("Undefined operation: \"#{value1} #{@operator} #{value2}\".")
       end
     end
 
     private
 
     def operand_to_sass(op, side, opts)
-      return "(#{op.to_sass(opts)})" if op.is_a?(List)
+      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)

data/lib/sass/script/{string_interpolation.rb → tree/string_interpolation.rb}

@@ -1,4 +1,4 @@
-module Sass::Script
+module Sass::Script::Tree
   # A SassScript object representing `#{}` interpolation within a string.
   #
   # @see Interpolation
@@ -60,20 +60,30 @@ module Sass::Script
       [@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::String] The SassScript string that is the value of the interpolation
+    # @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::String) ? mid.value : mid.to_s)
+      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s)
       res << @after.perform(environment).value
-      opts(Sass::Script::String.new(res, before.type))
+      opts(Sass::Script::Value::String.new(res, before.type))
     end
 
     private

data/lib/sass/script/{unary_operation.rb → tree/unary_operation.rb}

@@ -1,12 +1,17 @@
-module Sass::Script
+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
-    # @param operand [Script::Node] The parse-tree node
-    #   for the object of the operator
-    # @param operator [Symbol] The operator to perform
+    # @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
@@ -26,7 +31,7 @@ module Sass::Script
            (operand =~ Sass::SCSS::RX::IDENT) == 0)
         operand = "(#{@operand.to_sass(opts)})"
       end
-      op = Lexer::OPERATORS_REVERSE[@operator]
+      op = Sass::Script::Lexer::OPERATORS_REVERSE[@operator]
       op + (op =~ /[a-z]/ ? " " : "") + operand
     end
 
@@ -38,20 +43,27 @@ module Sass::Script
       [@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 [Literal] The SassScript object that is the value of the operation
+    # @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}"
-      literal = @operand.perform(environment)
-      literal.send(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} #{literal}\".")
+      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.gsub(/-/, "_")
+      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,15 @@
+# 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'

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)
+      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

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

@@ -0,0 +1,238 @@
+module Sass::Script::Value
+  # The abstract superclass for SassScript objects.
+  #
+  # Many of these methods, especially the ones that correspond to SassScript operations,
+  # are designed to be overridden by subclasses which may change the semantics somewhat.
+  # The operations listed here are just the defaults.
+  class Base
+    # Returns the Ruby value of the value.
+    # The type of this value varies based on the subclass.
+    #
+    # @return [Object]
+    attr_reader :value
+
+    # The source range in the document on which this node appeared.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :source_range
+
+    # Creates a new value.
+    #
+    # @param value [Object] The object for \{#value}
+    def initialize(value = nil)
+      @value = value.freeze
+    end
+
+    # Sets the options hash for this node,
+    # as well as for all child nodes.
+    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #
+    # @param options [{Symbol => Object}] The options
+    attr_writer :options
+
+    # Returns the options hash for this node.
+    #
+    # @return [{Symbol => Object}]
+    # @raise [Sass::SyntaxError] if the options hash hasn't been set.
+    #   This should only happen when the value was created
+    #   outside of the parser and \{#to\_s} was called on it
+    def options
+      return @options if @options
+      raise Sass::SyntaxError.new(<<MSG)
+The #options attribute is not set on this #{self.class}.
+  This error is probably occurring because #to_s was called
+  on this value within a custom Sass function without first
+  setting the #options attribute.
+MSG
+    end
+
+    # The SassScript `==` operation.
+    # **Note that this returns a {Sass::Script::Value::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Sass::Script::Value::Bool] True if this value is the same as the other,
+    #   false otherwise
+    def eq(other)
+      Sass::Script::Value::Bool.new(self.class == other.class && value == other.value)
+    end
+
+    # The SassScript `!=` operation.
+    # **Note that this returns a {Sass::Script::Value::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Sass::Script::Value::Bool] False if this value is the same as the other,
+    #   true otherwise
+    def neq(other)
+      Sass::Script::Value::Bool.new(!eq(other).to_bool)
+    end
+
+    # The SassScript `==` operation.
+    # **Note that this returns a {Sass::Script::Value::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Sass::Script::Value::Bool] True if this value is the same as the other,
+    #   false otherwise
+    def unary_not
+      Sass::Script::Value::Bool.new(!to_bool)
+    end
+
+    # The SassScript `=` operation
+    # (used for proprietary MS syntax like `alpha(opacity=20)`).
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing both values
+    #   separated by `"="`
+    def single_eq(other)
+      Sass::Script::Value::String.new("#{to_s}=#{other.to_s}")
+    end
+
+    # The SassScript `+` operation.
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing both values
+    #   without any separation
+    def plus(other)
+      if other.is_a?(Sass::Script::Value::String)
+        return Sass::Script::Value::String.new(to_s + other.value, other.type)
+      end
+      Sass::Script::Value::String.new(to_s + other.to_s)
+    end
+
+    # The SassScript `-` operation.
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing both values
+    #   separated by `"-"`
+    def minus(other)
+      Sass::Script::Value::String.new("#{to_s}-#{other.to_s}")
+    end
+
+    # The SassScript `/` operation.
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing both values
+    #   separated by `"/"`
+    def div(other)
+      Sass::Script::Value::String.new("#{to_s}/#{other.to_s}")
+    end
+
+    # The SassScript unary `+` operation (e.g. `+$a`).
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing the value
+    #   preceded by `"+"`
+    def unary_plus
+      Sass::Script::Value::String.new("+#{to_s}")
+    end
+
+    # The SassScript unary `-` operation (e.g. `-$a`).
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing the value
+    #   preceded by `"-"`
+    def unary_minus
+      Sass::Script::Value::String.new("-#{to_s}")
+    end
+
+    # The SassScript unary `/` operation (e.g. `/$a`).
+    #
+    # @param other [Value] The right-hand side of the operator
+    # @return [Script::Value::String] A string containing the value
+    #   preceded by `"/"`
+    def unary_div
+      Sass::Script::Value::String.new("/#{to_s}")
+    end
+
+    # Returns the hash code of this value. Two objects' hash codes should be
+    # equal if the objects are equal.
+    #
+    # @return [Fixnum] The hash code.
+    def hash
+      value.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    # @return [String] A readable representation of the value
+    def inspect
+      value.inspect
+    end
+
+    # @return [Boolean] `true` (the Ruby boolean value)
+    def to_bool
+      true
+    end
+
+    # Compares this object with another.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this value is equivalent to `other`
+    def ==(other)
+      eq(other).to_bool
+    end
+
+    # @return [Fixnum] The integer value of this value
+    # @raise [Sass::SyntaxError] if this value isn't an integer
+    def to_i
+      raise Sass::SyntaxError.new("#{inspect} is not an integer.")
+    end
+
+    # @raise [Sass::SyntaxError] if this value isn't an integer
+    def assert_int!; to_i; end
+
+    # Returns the separator for this value. For non-list-like values or the
+    # empty list, this will be `nil`. For lists or maps, it will be `:space` or
+    # `:comma`.
+    #
+    # @return [Symbol]
+    def separator; nil; end
+
+    # Returns the value of this value as a list.
+    # Single values are considered the same as single-element lists.
+    #
+    # @return [Array<Value>] This value as a list
+    def to_a
+      [self]
+    end
+
+    # Returns the value of this value as a hash. Most values don't have hash
+    # representations, but [Map]s and empty [List]s do.
+    #
+    # @return [Hash<Value, Value>] This value as a hash
+    # @raise [Sass::SyntaxError] if this value doesn't have a hash representation
+    def to_h
+      raise Sass::SyntaxError.new("#{inspect} is not a map.")
+    end
+
+    # Returns the string representation of this value
+    # as it would be output to the CSS document.
+    #
+    # @return [String]
+    def to_s(opts = {})
+      Sass::Util.abstract(self)
+    end
+    alias_method :to_sass, :to_s
+
+    # Returns whether or not this object is null.
+    #
+    # @return [Boolean] `false`
+    def null?
+      false
+    end
+
+    protected
+
+    # Evaluates the value.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Value] This value
+    def _perform(environment)
+      self
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Sass::Script::Value
+  # A SassScript object representing a boolean (true or false) value.
+  class Bool < Base
+    # The true value in SassScript.
+    #
+    # This is assigned before new is overridden below so that we use the default implementation.
+    TRUE  = new(true)
+
+    # The false value in SassScript.
+    #
+    # This is assigned before new is overridden below so that we use the default implementation.
+    FALSE = new(false)
+
+    # We override object creation so that users of the core API
+    # will not need to know that booleans are specific constants.
+    #
+    # @param value A ruby value that will be tested for truthiness.
+    # @return [Bool] TRUE if value is truthy, FALSE if value is falsey
+    def self.new(value)
+      value ? TRUE : FALSE
+    end
+
+    def eq(other)
+      return other.eq(self) if other.is_a?(DeprecatedFalse)
+      super
+    end
+
+    # The Ruby value of the boolean.
+    #
+    # @return [Boolean]
+    attr_reader :value
+    alias_method :to_bool, :value
+
+    # @return [String] "true" or "false"
+    def to_s(opts = {})
+      @value.to_s
+    end
+    alias_method :to_sass, :to_s
+  end
+end