oreorenasass 3.4.0

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

@@ -0,0 +1,45 @@
+module Sass::Script::Tree
+  # The parse tree node for a literal scalar value. This wraps an instance of
+  # {Sass::Script::Value::Base}.
+  #
+  # List literals should use {ListLiteral} instead.
+  class Literal < Node
+    # The wrapped value.
+    #
+    # @return [Sass::Script::Value::Base]
+    attr_reader :value
+
+    # Creates a new literal value.
+    #
+    # @param value [Sass::Script::Value::Base]
+    # @see #value
+    def initialize(value)
+      @value = value
+    end
+
+    # @see Node#children
+    def children; []; end
+
+    # @see Node#to_sass
+    def to_sass(opts = {}); value.to_sass(opts); end
+
+    # @see Node#deep_copy
+    def deep_copy; dup; end
+
+    # @see Node#options=
+    def options=(options)
+      value.options = options
+    end
+
+    def inspect
+      value.inspect
+    end
+
+    protected
+
+    def _perform(environment)
+      value.source_range = source_range
+      value
+    end
+  end
+end

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(Sass::Util.to_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,109 @@
+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 [Fixnum]
+    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#sass_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.
+    #
+    # @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
+
+    protected
+
+    # Converts underscores to dashes if the :dasherize option is set.
+    def dasherize(s, opts)
+      if opts[:dasherize]
+        s.gsub(/_/, '-')
+      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,103 @@
+module Sass::Script::Tree
+  # A SassScript parse node representing a binary operation,
+  # such as `$a + $b` or `"foo" + 1`.
+  class Operation < Node
+    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
+        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
+    end
+
+    private
+
+    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,104 @@
+module Sass::Script::Tree
+  # A SassScript object representing `#{}` interpolation within a string.
+  #
+  # @see Interpolation
+  class StringInterpolation < Node
+    # Interpolation in a string is of the form `"before #{mid} after"`,
+    # where `before` and `after` may include more interpolation.
+    #
+    # @param before [Node] The string before the interpolation
+    # @param mid [Node] The SassScript within the interpolation
+    # @param after [Node] The string after the interpolation
+    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 = {})
+      # We can get rid of all of this when we remove the deprecated :equals context
+      # XXX CE: It's gone now but I'm not sure what can be removed now.
+      before_unquote, before_quote_char, before_str = parse_str(@before.to_sass(opts))
+      after_unquote, after_quote_char, after_str = parse_str(@after.to_sass(opts))
+      unquote = before_unquote || after_unquote ||
+        (before_quote_char && !after_quote_char && !after_str.empty?) ||
+        (!before_quote_char && after_quote_char && !before_str.empty?)
+      quote_char =
+        if before_quote_char && after_quote_char && before_quote_char != after_quote_char
+          before_str.gsub!("\\'", "'")
+          before_str.gsub!('"', "\\\"")
+          after_str.gsub!("\\'", "'")
+          after_str.gsub!('"', "\\\"")
+          '"'
+        else
+          before_quote_char || after_quote_char
+        end
+
+      res = ""
+      res << 'unquote(' if unquote
+      res << quote_char if quote_char
+      res << before_str
+      res << '#{' << @mid.to_sass(opts) << '}'
+      res << after_str
+      res << quote_char if quote_char
+      res << ')' if unquote
+      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 parse_str(str)
+      case str
+      when /^unquote\((["'])(.*)\1\)$/
+        return true, $1, $2
+      when '""'
+        return false, nil, ""
+      when /^(["'])(.*)\1$/
+        return false, $1, $2
+      else
+        return false, nil, str
+      end
+    end
+  end
+end