Class: Sass::Selector::CommaSequence

Inherits:
AbstractSequence show all
Defined in:
lib/sass/selector/comma_sequence.rb

Overview

A comma-separated sequence of selectors.

Instance Attribute Summary collapse

Attributes inherited from AbstractSequence

#filename, #line

Instance Method Summary collapse

Methods inherited from AbstractSequence

#_specificity, #eql?, #has_placeholder?, #hash, #specificity

Constructor Details

#initialize(seqs) ⇒ CommaSequence


12
13
14
# File 'lib/sass/selector/comma_sequence.rb', line 12

def initialize(seqs)
  @members = seqs
end

Instance Attribute Details

#membersArray<Sequence> (readonly)

The comma-separated selector sequences represented by this class.


9
10
11
# File 'lib/sass/selector/comma_sequence.rb', line 9

def members
  @members
end

Instance Method Details

#contains_parent_ref?Boolean

Returns whether there's a Parent selector anywhere in this sequence.


43
44
45
# File 'lib/sass/selector/comma_sequence.rb', line 43

def contains_parent_ref?
  @members.any? {|sel| sel.contains_parent_ref?}
end

#do_extend(extends, parent_directives = [], replace = false, seen = Set.new, original = true) ⇒ CommaSequence

TODO:

Link this to the reference documentation on @extend when such a thing exists.

Non-destrucively extends this selector with the extensions specified in a hash (which should come from Tree::Visitors::Cssize).

The extensions to perform on this selector


68
69
70
71
72
73
# File 'lib/sass/selector/comma_sequence.rb', line 68

def do_extend(extends, parent_directives = [], replace = false, seen = Set.new,
    original = true)
  CommaSequence.new(members.map do |seq|
    seq.do_extend(extends, parent_directives, replace, seen, original)
  end.flatten)
end

#inspectString

Returns a string representation of the sequence. This is basically the selector string.


157
158
159
# File 'lib/sass/selector/comma_sequence.rb', line 157

def inspect
  members.map {|m| m.inspect}.join(", ")
end

#populate_extends(extends, extendee, extend_node = nil, parent_directives = [])

Populates a subset map that can then be used to extend selectors. This registers an extension with this selector as the extender and extendee as the extendee.

The subset map representing the extensions to perform.

Raises:


100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
# File 'lib/sass/selector/comma_sequence.rb', line 100

def populate_extends(extends, extendee, extend_node = nil, parent_directives = [])
  extendee.members.each do |seq|
    if seq.members.size > 1
      raise Sass::SyntaxError.new("Can't extend #{seq}: can't extend nested selectors")
    end

    sseq = seq.members.first
    if !sseq.is_a?(Sass::Selector::SimpleSequence)
      raise Sass::SyntaxError.new("Can't extend #{seq}: invalid selector")
    elsif sseq.members.any? {|ss| ss.is_a?(Sass::Selector::Parent)}
      raise Sass::SyntaxError.new("Can't extend #{seq}: can't extend parent selectors")
    end

    sel = sseq.members
    members.each do |member|
      unless member.members.last.is_a?(Sass::Selector::SimpleSequence)
        raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
      end

      extends[sel] = Sass::Tree::Visitors::Cssize::Extend.new(
        member, sel, extend_node, parent_directives, :not_found)
    end
  end
end

#resolve_parent_refs(super_cseq, implicit_parent = true) ⇒ CommaSequence

Resolves the Parent selectors within this selector by replacing them with the given parent selector, handling commas appropriately.

Raises:


26
27
28
29
30
31
32
33
34
35
36
37
38
# File 'lib/sass/selector/comma_sequence.rb', line 26

def resolve_parent_refs(super_cseq, implicit_parent = true)
  if super_cseq.nil?
    if contains_parent_ref?
      raise Sass::SyntaxError.new(
        "Base-level rules cannot contain the parent-selector-referencing character '&'.")
    end
    return self
  end

  CommaSequence.new(Sass::Util.flatten_vertically(@members.map do |seq|
    seq.resolve_parent_refs(super_cseq, implicit_parent).members
  end))
end

#superselector?(cseq) ⇒ Boolean

Returns whether or not this selector matches all elements that the given selector matches (as well as possibly more).

Examples:

(.foo).superselector?(.foo.bar) #=> true
(.foo).superselector?(.bar) #=> false

83
84
85
# File 'lib/sass/selector/comma_sequence.rb', line 83

def superselector?(cseq)
  cseq.members.all? {|seq1| members.any? {|seq2| seq2.superselector?(seq1)}}
end

#to_s


162
163
164
# File 'lib/sass/selector/comma_sequence.rb', line 162

def to_s
  @members.join(", ").gsub(", \n", ",\n")
end

#to_sass_scriptSass::Script::Value::List

Returns a SassScript representation of this selector.


144
145
146
147
148
149
150
151
# File 'lib/sass/selector/comma_sequence.rb', line 144

def to_sass_script
  Sass::Script::Value::List.new(members.map do |seq|
    Sass::Script::Value::List.new(seq.members.map do |component|
      next if component == "\n"
      Sass::Script::Value::String.new(component.to_s)
    end.compact, :space)
  end, :comma)
end

#unify(other) ⇒ CommaSequence?

Unifies this with another comma selector to produce a selector that matches (a subset of) the intersection of the two inputs.

Raises:

  • (Sass::SyntaxError)

    If this selector cannot be unified. This will only ever occur when a dynamic selector, such as Parent or Interpolation, is used in unification. Since these selectors should be resolved by the time extension and unification happen, this exception will only ever be raised as a result of programmer error


136
137
138
139
# File 'lib/sass/selector/comma_sequence.rb', line 136

def unify(other)
  results = members.map {|seq1| other.members.map {|seq2| seq1.unify(seq2)}}.flatten.compact
  results.empty? ? nil : CommaSequence.new(results.map {|cseq| cseq.members}.flatten)
end