class Sass::Script::Tree::ListLiteral

{Sass::Tree::Value::List}.
A parse tree node representing a list literal. When resolved, this returns a

def _perform(environment)

def _perform(environment)
  list = Sass::Script::Value::List.new(
    elements.map {|e| e.perform(environment)},
    separator)
  list.source_range = source_range
  list.options = options
  list
end

def children; elements; end

Other tags:
    See: Node#children -
def children; elements; end

def deep_copy

Other tags:
    See: Node#deep_copy -
def deep_copy
  node = dup
  node.instance_variable_set('@elements', elements.map {|e| e.deep_copy})
  node
end

def initialize(elements, separator)

Parameters:
  • separator (Symbol) -- See \{#separator}
  • elements (Array) -- See \{#elements}
def initialize(elements, separator)
  @elements = elements
  @separator = separator
end

def inspect

def inspect
  "(#{elements.map {|e| e.inspect}.join(separator == :space ? ' ' : ', ')})"
end

def sep_str(opts = options)

def sep_str(opts = options)
  return ' ' if separator == :space
  return ',' if opts && opts[:style] == :compressed
  ', '
end

def to_sass(opts = {})

Other tags:
    See: Value#to_sass -
def to_sass(opts = {})
  return "()" if elements.empty?
  precedence = Sass::Script::Parser.precedence_of(separator)
  members = elements.map do |v|
    if v.is_a?(ListLiteral) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
        separator == :space && v.is_a?(UnaryOperation) &&
        (v.operator == :minus || v.operator == :plus)
      "(#{v.to_sass(opts)})"
    else
      v.to_sass(opts)
    end
  end
  return "(#{members.first},)" if separator == :comma && members.length == 1
  members.join(sep_str(nil))
end