classiccms 0.3.0 → 0.3.1

data/vendor/bundle/gems/sass-3.1.19/lib/sass/selector/sequence.rb

@@ -0,0 +1,296 @@
+module Sass
+  module Selector
+    # An operator-separated sequence of
+    # {SimpleSequence simple selector sequences}.
+    class Sequence < AbstractSequence
+      # Sets the line of the Sass template on which this selector was declared.
+      # This also sets the line for all child selectors.
+      #
+      # @param line [Fixnum]
+      # @return [Fixnum]
+      def line=(line)
+        members.each {|m| m.line = line if m.is_a?(SimpleSequence)}
+        line
+      end
+
+      # Sets the name of the file in which this selector was declared,
+      # or `nil` if it was not declared in a file (e.g. on stdin).
+      # This also sets the filename for all child selectors.
+      #
+      # @param filename [String, nil]
+      # @return [String, nil]
+      def filename=(filename)
+        members.each {|m| m.filename = filename if m.is_a?(SimpleSequence)}
+        filename
+      end
+
+      # The array of {SimpleSequence simple selector sequences}, operators, and newlines.
+      # The operators are strings such as `"+"` and `">"`
+      # representing the corresponding CSS operators.
+      # Newlines are also newline strings;
+      # these aren't semantically relevant,
+      # but they do affect formatting.
+      #
+      # @return [Array<SimpleSequence, String>]
+      attr_reader :members
+
+      # @param seqs_and_ops [Array<SimpleSequence, String>] See \{#members}
+      def initialize(seqs_and_ops)
+        @members = seqs_and_ops
+      end
+
+      # Resolves the {Parent} selectors within this selector
+      # by replacing them with the given parent selector,
+      # handling commas appropriately.
+      #
+      # @param super_seq [Sequence] The parent selector sequence
+      # @return [Sequence] This selector, with parent references resolved
+      # @raise [Sass::SyntaxError] If a parent selector is invalid
+      def resolve_parent_refs(super_seq)
+        members = @members
+        nl = (members.first == "\n" && members.shift)
+        unless members.any? do |seq_or_op|
+            seq_or_op.is_a?(SimpleSequence) && seq_or_op.members.first.is_a?(Parent)
+          end
+          members = []
+          members << nl if nl
+          members << SimpleSequence.new([Parent.new])
+          members += @members
+        end
+
+        Sequence.new(
+          members.map do |seq_or_op|
+            next seq_or_op unless seq_or_op.is_a?(SimpleSequence)
+            seq_or_op.resolve_parent_refs(super_seq)
+          end.flatten)
+      end
+
+      # Non-destructively extends this selector with the extensions specified in a hash
+      # (which should come from {Sass::Tree::Visitors::Cssize}).
+      #
+      # @overload def do_extend(extends)
+      # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
+      #                                       Sass::Tree::Visitors::Cssize::Extend}]
+      #   The extensions to perform on this selector
+      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
+      #   The directives containing this selector.
+      # @return [Array<Sequence>] A list of selectors generated
+      #   by extending this selector with `extends`.
+      #   These correspond to a {CommaSequence}'s {CommaSequence#members members array}.
+      # @see CommaSequence#do_extend
+      def do_extend(extends, parent_directives, seen = Set.new)
+        paths = Sass::Util.paths(members.map do |sseq_or_op|
+            next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)
+            extended = sseq_or_op.do_extend(extends, parent_directives, seen)
+            choices = extended.map {|seq| seq.members}
+            choices.unshift([sseq_or_op]) unless extended.any? {|seq| seq.superselector?(sseq_or_op)}
+            choices
+          end)
+        Sass::Util.flatten(paths.map {|path| weave(path)}, 1).map {|p| Sequence.new(p)}
+      end
+
+      # Returns whether or not this selector matches all elements
+      # that the given selector matches (as well as possibly more).
+      #
+      # @example
+      #   (.foo).superselector?(.foo.bar) #=> true
+      #   (.foo).superselector?(.bar) #=> false
+      #   (.bar .foo).superselector?(.foo) #=> false
+      # @param sseq [SimpleSequence]
+      # @return [Boolean]
+      def superselector?(sseq)
+        return false unless members.size == 1
+        members.last.superselector?(sseq)
+      end
+
+      # @see Simple#to_a
+      def to_a
+        ary = @members.map {|seq_or_op| seq_or_op.is_a?(SimpleSequence) ? seq_or_op.to_a : seq_or_op}
+        Sass::Util.intersperse(ary, " ").flatten.compact
+      end
+
+      # Returns a string representation of the sequence.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        members.map {|m| m.inspect}.join(" ")
+      end
+
+      private
+
+      # Conceptually, this expands "parenthesized selectors".
+      # That is, if we have `.A .B {@extend .C}` and `.D .C {...}`,
+      # this conceptually expands into `.D .C, .D (.A .B)`,
+      # and this function translates `.D (.A .B)` into `.D .A .B, .A.D .B, .D .A .B`.
+      #
+      # @param path [Array<Array<SimpleSequence or String>>] A list of parenthesized selector groups.
+      # @return [Array<Array<SimpleSequence or String>>] A list of fully-expanded selectors.
+      def weave(path)
+        befores = [[]]
+        afters = path.dup
+
+        until afters.empty?
+          current = afters.shift.dup
+          last_current = [current.pop]
+          while !current.empty? && last_current.first.is_a?(String) || current.last.is_a?(String)
+            last_current.unshift(current.pop)
+          end
+          befores = Sass::Util.flatten(befores.map do |before|
+              next [] unless sub = subweave(before, current)
+              sub.map {|seqs| seqs + last_current}
+            end, 1)
+        end
+        return befores
+      end
+
+      # This interweaves two lists of selectors,
+      # returning all possible orderings of them (including using unification)
+      # that maintain the relative ordering of the input arrays.
+      #
+      # For example, given `.foo .bar` and `.baz .bang`,
+      # this would return `.foo .bar .baz .bang`, `.foo .bar.baz .bang`,
+      # `.foo .baz .bar .bang`, `.foo .baz .bar.bang`, `.foo .baz .bang .bar`,
+      # and so on until `.baz .bang .foo .bar`.
+      #
+      # @param seq1 [Array<SimpleSequence or String>]
+      # @param seq2 [Array<SimpleSequence or String>]
+      # @return [Array<Array<SimpleSequence or String>>]
+      def subweave(seq1, seq2)
+        return [seq2] if seq1.empty?
+        return [seq1] if seq2.empty?
+
+        return unless init = merge_initial_ops(seq1, seq2)
+        seq1 = group_selectors(seq1)
+        seq2 = group_selectors(seq2)
+        lcs = Sass::Util.lcs(seq2, seq1) do |s1, s2|
+          next s1 if s1 == s2
+          next unless s1.first.is_a?(SimpleSequence) && s2.first.is_a?(SimpleSequence)
+          next s2 if subweave_superselector?(s1, s2)
+          next s1 if subweave_superselector?(s2, s1)
+        end
+
+        diff = [[init]]
+        until lcs.empty?
+          diff << chunks(seq1, seq2) {|s| subweave_superselector?(s.first, lcs.first)} << [lcs.shift]
+          seq1.shift
+          seq2.shift
+        end
+        diff << chunks(seq1, seq2) {|s| s.empty?}
+        diff.reject! {|c| c.empty?}
+
+        Sass::Util.paths(diff).map {|p| p.flatten}
+      end
+
+      # Extracts initial selector operators (`"+"`, `">"`, `"~"`, and `"\n"`)
+      # from two sequences and merges them together into a single array of
+      # selector operators.
+      #
+      # @param seq1 [Array<SimpleSequence or String>]
+      # @param seq2 [Array<SimpleSequence or String>]
+      # @return [Array<String>, nil] If there are no operators in the merged
+      #   sequence, this will be the empty array. If the operators cannot be
+      #   merged, this will be nil.
+      def merge_initial_ops(seq1, seq2)
+        ops1, ops2 = [], []
+        ops1 << seq1.shift while seq1.first.is_a?(String)
+        ops2 << seq2.shift while seq2.first.is_a?(String)
+
+        newline = false
+        newline ||= !!ops1.shift if ops1.first == "\n"
+        newline ||= !!ops2.shift if ops2.first == "\n"
+
+        # If neither sequence is a subsequence of the other, they cannot be
+        # merged successfully
+        lcs = Sass::Util.lcs(ops1, ops2)
+        return unless lcs == ops1 || lcs == ops2
+        return (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
+      end
+
+      # Takes initial subsequences of `seq1` and `seq2` and returns all
+      # orderings of those subsequences. The initial subsequences are determined
+      # by a block.
+      #
+      # Destructively removes the initial subsequences of `seq1` and `seq2`.
+      #
+      # For example, given `(A B C | D E)` and `(1 2 | 3 4 5)` (with `|`
+      # denoting the boundary of the initial subsequence), this would return
+      # `[(A B C 1 2), (1 2 A B C)]`. The sequences would then be `(D E)` and
+      # `(3 4 5)`.
+      #
+      # @param seq1 [Array]
+      # @param seq2 [Array]
+      # @yield [a] Used to determine when to cut off the initial subsequences.
+      #   Called repeatedly for each sequence until it returns true.
+      # @yieldparam a [Array] A final subsequence of one input sequence after
+      #   cutting off some initial subsequence.
+      # @yieldreturn [Boolean] Whether or not to cut off the initial subsequence
+      #   here.
+      def chunks(seq1, seq2)
+        chunk1 = []
+        chunk1 << seq1.shift until yield seq1
+        chunk2 = []
+        chunk2 << seq2.shift until yield seq2
+        return [] if chunk1.empty? && chunk2.empty?
+        return [chunk2] if chunk1.empty?
+        return [chunk1] if chunk2.empty?
+        [chunk1 + chunk2, chunk2 + chunk1]
+      end
+
+      # Groups a sequence into subsequences. The subsequences are determined by
+      # strings; adjacent non-string elements will be put into separate groups,
+      # but any element adjacent to a string will be grouped with that string.
+      #
+      # For example, `(A B "C" D E "F" G "H" "I" J)` will become `[(A) (B "C" D)
+      # (E "F" G "H" "I" J)]`.
+      #
+      # @param seq [Array]
+      # @return [Array<Array>]
+      def group_selectors(seq)
+        newseq = []
+        tail = seq.dup
+        until tail.empty?
+          head = []
+          begin
+            head << tail.shift
+          end while !tail.empty? && head.last.is_a?(String) || tail.first.is_a?(String)
+          newseq << head
+        end
+        return newseq
+      end
+
+      # Given two sequences of simple selectors, returns whether `sseq1` is a
+      # superselector of `sseq2`.
+      #
+      # @param sseq1 [Array<SimpleSelector or String>]
+      # @param sseq2 [Array<SimpleSelector or String>]
+      # @return [Boolean]
+      def subweave_superselector?(sseq1, sseq2)
+        if sseq1.size > 1
+          # More complex selectors are never superselectors of less complex ones
+          return unless sseq2.size > 1
+          # .foo ~ .bar is a superselector of .foo + .bar
+          return unless sseq1[1] == "~" ? sseq2[1] != ">" : sseq2[1] == sseq1[1]
+          return unless sseq1.first.superselector?(sseq2.first)
+          return true if sseq1.size == 2
+          return false if sseq2.size == 2
+          return subweave_superselector?(sseq1[2..-1], sseq2[2..-1])
+        elsif sseq2.size > 1
+          return true if sseq2[1] == ">" && sseq1.first.superselector?(sseq2.first)
+          return false if sseq2.size == 2
+          return subweave_superselector?(sseq1, sseq2[2..-1])
+        else
+          sseq1.first.superselector?(sseq2.first)
+        end
+      end
+
+      def _hash
+        members.reject {|m| m == "\n"}.hash
+      end
+
+      def _eql?(other)
+        other.members.reject {|m| m == "\n"}.eql?(self.members.reject {|m| m == "\n"})
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/selector/simple.rb

@@ -0,0 +1,119 @@
+module Sass
+  module Selector
+    # The abstract superclass for simple selectors
+    # (that is, those that don't compose multiple selectors).
+    class Simple
+      # The line of the Sass template on which this selector was declared.
+      #
+      # @return [Fixnum]
+      attr_accessor :line
+
+      # The name of the file in which this selector was declared,
+      # or `nil` if it was not declared in a file (e.g. on stdin).
+      #
+      # @return [String, nil]
+      attr_accessor :filename
+
+      # Returns a representation of the node
+      # as an array of strings and potentially {Sass::Script::Node}s
+      # (if there's interpolation in the selector).
+      # When the interpolation is resolved and the strings are joined together,
+      # this will be the string representation of this node.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      def to_a
+        Sass::Util.abstract(self)
+      end
+
+      # Returns a string representation of the node.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
+      end
+
+      # @see \{#inspect}
+      # @return [String]
+      def to_s
+        inspect
+      end
+
+      # Returns a hash code for this selector object.
+      #
+      # By default, this is based on the value of \{#to\_a},
+      # so if that contains information irrelevant to the identity of the selector,
+      # this should be overridden.
+      #
+      # @return [Fixnum]
+      def hash
+        @_hash ||= to_a.hash
+      end
+
+      # Checks equality between this and another object.
+      #
+      # By default, this is based on the value of \{#to\_a},
+      # so if that contains information irrelevant to the identity of the selector,
+      # this should be overridden.
+      #
+      # @param other [Object] The object to test equality against
+      # @return [Boolean] Whether or not this is equal to `other`
+      def eql?(other)
+        other.class == self.class && other.hash == self.hash && other.to_a.eql?(to_a)
+      end
+      alias_method :==, :eql?
+
+      # Unifies this selector with a {SimpleSequence}'s {SimpleSequence#members members array},
+      # returning another `SimpleSequence` members array
+      # that matches both this selector and the input selector.
+      #
+      # By default, this just appends this selector to the end of the array
+      # (or returns the original array if this selector already exists in it).
+      #
+      # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
+      # @return [Array<Simple>, nil] A {SimpleSequence} {SimpleSequence#members members array}
+      #   matching both `sels` and this selector,
+      #   or `nil` if this is impossible (e.g. unifying `#foo` and `#bar`)
+      # @raise [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
+      def unify(sels)
+        return sels if sels.any? {|sel2| eql?(sel2)}
+        sels_with_ix = Sass::Util.enum_with_index(sels)
+        _, i =
+          if self.is_a?(Pseudo) || self.is_a?(SelectorPseudoClass)
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.final? || sels.last.type == :element)}
+          else
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) || sel.is_a?(SelectorPseudoClass)}
+          end
+        return sels + [self] unless i
+        return sels[0...i] + [self] + sels[i..-1]
+      end
+
+      protected
+
+      # Unifies two namespaces,
+      # returning a namespace that works for both of them if possible.
+      #
+      # @param ns1 [String, nil] The first namespace.
+      #   `nil` means none specified, e.g. `foo`.
+      #   The empty string means no namespace specified, e.g. `|foo`.
+      #   `"*"` means any namespace is allowed, e.g. `*|foo`.
+      # @param ns2 [String, nil] The second namespace. See `ns1`.
+      # @return [Array(String or nil, Boolean)]
+      #   The first value is the unified namespace, or `nil` for no namespace.
+      #   The second value is whether or not a namespace that works for both inputs
+      #   could be found at all.
+      #   If the second value is `false`, the first should be ignored.
+      def unify_namespaces(ns1, ns2)
+        return nil, false unless ns1 == ns2 || ns1.nil? || ns1 == ['*'] || ns2.nil? || ns2 == ['*']
+        return ns2, true if ns1 == ['*']
+        return ns1, true if ns2 == ['*']
+        return ns1 || ns2, true
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/selector/simple_sequence.rb

@@ -0,0 +1,154 @@
+module Sass
+  module Selector
+    # A unseparated sequence of selectors
+    # that all apply to a single element.
+    # For example, `.foo#bar[attr=baz]` is a simple sequence
+    # of the selectors `.foo`, `#bar`, and `[attr=baz]`.
+    class SimpleSequence < AbstractSequence
+      # The array of individual selectors.
+      #
+      # @return [Array<Simple>]
+      attr_reader :members
+
+      # Returns the element or universal selector in this sequence,
+      # if it exists.
+      #
+      # @return [Element, Universal, nil]
+      def base
+        @base ||= (members.first if members.first.is_a?(Element) || members.first.is_a?(Universal))
+      end
+
+      # Returns the non-base selectors in this sequence.
+      #
+      # @return [Set<Simple>]
+      def rest
+        @rest ||= Set.new(base ? members[1..-1] : members)
+      end
+
+      # @param selectors [Array<Simple>] See \{#members}
+      def initialize(selectors)
+        @members = selectors
+      end
+
+      # Resolves the {Parent} selectors within this selector
+      # by replacing them with the given parent selector,
+      # handling commas appropriately.
+      #
+      # @param super_seq [Sequence] The parent selector sequence
+      # @return [Array<SimpleSequence>] This selector, with parent references resolved.
+      #   This is an array because the parent selector is itself a {Sequence}
+      # @raise [Sass::SyntaxError] If a parent selector is invalid
+      def resolve_parent_refs(super_seq)
+        # Parent selector only appears as the first selector in the sequence
+        return [self] unless @members.first.is_a?(Parent)
+
+        return super_seq.members if @members.size == 1
+        unless super_seq.members.last.is_a?(SimpleSequence)
+          raise Sass::SyntaxError.new("Invalid parent selector: " + super_seq.to_a.join)
+        end
+
+        super_seq.members[0...-1] +
+          [SimpleSequence.new(super_seq.members.last.members + @members[1..-1])]
+      end
+
+      # Non-destrucively extends this selector with the extensions specified in a hash
+      # (which should come from {Sass::Tree::Visitors::Cssize}).
+      #
+      # @overload def do_extend(extends, parent_directives)
+      # @param extends [{Selector::Simple =>
+      #                  Sass::Tree::Visitors::Cssize::Extend}]
+      #   The extensions to perform on this selector
+      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
+      #   The directives containing this selector.
+      # @return [Array<Sequence>] A list of selectors generated
+      #   by extending this selector with `extends`.
+      # @see CommaSequence#do_extend
+      def do_extend(extends, parent_directives, seen = Set.new)
+        extends.get(members.to_set).map do |ex, sels|
+          # If A {@extend B} and C {...},
+          # ex.extender is A, sels is B, and self is C
+
+          self_without_sel = self.members - sels
+          next unless unified = ex.extender.members.last.unify(self_without_sel)
+          next unless check_directives_match!(ex, parent_directives)
+          [sels, ex.extender.members[0...-1] + [unified]]
+        end.compact.map do |sels, seq|
+          seq = Sequence.new(seq)
+          next [] if seen.include?(sels)
+          seq.do_extend(extends, parent_directives, seen + [sels])
+        end.flatten.uniq
+      end
+
+      # Unifies this selector with another {SimpleSequence}'s {SimpleSequence#members members array},
+      # returning another `SimpleSequence`
+      # that matches both this selector and the input selector.
+      #
+      # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
+      # @return [SimpleSequence, nil] A {SimpleSequence} matching both `sels` and this selector,
+      #   or `nil` if this is impossible (e.g. unifying `#foo` and `#bar`)
+      # @raise [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
+      def unify(sels)
+        return unless sseq = members.inject(sels) do |sseq, sel|
+          return unless sseq
+          sel.unify(sseq)
+        end
+        SimpleSequence.new(sseq)
+      end
+
+      # Returns whether or not this selector matches all elements
+      # that the given selector matches (as well as possibly more).
+      #
+      # @example
+      #   (.foo).superselector?(.foo.bar) #=> true
+      #   (.foo).superselector?(.bar) #=> false
+      # @param sseq [SimpleSequence]
+      # @return [Boolean]
+      def superselector?(sseq)
+        (base.nil? || base.eql?(sseq.base)) && rest.subset?(sseq.rest)
+      end
+
+      # @see Simple#to_a
+      def to_a
+        @members.map {|sel| sel.to_a}.flatten
+      end
+
+      # Returns a string representation of the sequence.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        members.map {|m| m.inspect}.join
+      end
+
+      private
+
+      def check_directives_match!(extend, parent_directives)
+        dirs1 = extend.directives.map {|d| d.value}
+        dirs2 = parent_directives.map {|d| d.value}
+        return true if Sass::Util.subsequence?(dirs1, dirs2)
+
+        Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING on line #{extend.node.line}#{" of #{extend.node.filename}" if extend.node.filename}:
+  @extending an outer selector from within #{extend.directives.last.name} is deprecated.
+  You may only @extend selectors within the same directive.
+  This will be an error in Sass 3.3.
+  It can only work once @extend is supported natively in the browser.
+WARNING
+        return false
+      end
+
+      def _hash
+        [base, Sass::Util.set_hash(rest)].hash
+      end
+
+      def _eql?(other)
+        other.base.eql?(self.base) && Sass::Util.set_eql?(other.rest, self.rest)
+      end
+    end
+  end
+end