torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/selector/abstract_sequence.rb

@@ -1,62 +0,0 @@
-module Sass
-  module Selector
-    # The abstract parent class of the various selector sequence classes.
-    #
-    # All subclasses should implement a `members` method
-    # that returns an array of object that respond to `#line=` and `#filename=`.
-    class AbstractSequence
-      # The line of the Sass template on which this selector was declared.
-      #
-      # @return [Fixnum]
-      attr_reader :line
-
-      # The name of the file in which this selector was declared.
-      #
-      # @return [String, nil]
-      attr_reader :filename
-
-      # 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}
-        @line = 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}
-        @filename = filename
-      end
-
-      # Returns a hash code for this sequence.
-      #
-      # Subclasses should define `#_hash` rather than overriding this method,
-      # which automatically handles memoizing the result.
-      #
-      # @return [Fixnum]
-      def hash
-        @_hash ||= _hash
-      end
-
-      # Checks equality between this and another object.
-      #
-      # Subclasses should define `#_eql?` rather than overriding this method,
-      # which handles checking class equality and hash equality.
-      #
-      # @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 && _eql?(other)
-      end
-      alias_method :==, :eql?
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/selector/comma_sequence.rb

@@ -1,81 +0,0 @@
-module Sass
-  module Selector
-    # A comma-separated sequence of selectors.
-    class CommaSequence < AbstractSequence
-      # The comma-separated selector sequences
-      # represented by this class.
-      #
-      # @return [Array<Sequence>]
-      attr_reader :members
-
-      # @param seqs [Array<Sequence>] See \{#members}
-      def initialize(seqs)
-        @members = seqs
-      end
-
-      # Resolves the {Parent} selectors within this selector
-      # by replacing them with the given parent selector,
-      # handling commas appropriately.
-      #
-      # @param super_cseq [CommaSequence] The parent selector
-      # @return [CommaSequence] This selector, with parent references resolved
-      # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_cseq)
-        if super_cseq.nil?
-          if @members.any? do |sel|
-              sel.members.any? do |sel_or_op|
-                sel_or_op.is_a?(SimpleSequence) && sel_or_op.members.any? {|ssel| ssel.is_a?(Parent)}
-              end
-            end
-            raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '&'.")
-          end
-          return self
-        end
-
-        CommaSequence.new(
-          super_cseq.members.map do |super_seq|
-            @members.map {|seq| seq.resolve_parent_refs(super_seq)}
-          end.flatten)
-      end
-
-      # Non-destrucively extends this selector with the extensions specified in a hash
-      # (which should come from {Sass::Tree::Visitors::Cssize}).
-      #
-      # @todo Link this to the reference documentation on `@extend`
-      #   when such a thing exists.
-      #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
-      #   The extensions to perform on this selector
-      # @return [CommaSequence] A copy of this selector,
-      #   with extensions made according to `extends`
-      def do_extend(extends)
-        CommaSequence.new(members.map {|seq| seq.do_extend(extends)}.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
-
-      # @see Simple#to_a
-      def to_a
-        arr = Sass::Util.intersperse(@members.map {|m| m.to_a}, ", ").flatten
-        arr.delete("\n")
-        arr
-      end
-
-      private
-
-      def _hash
-        members.hash
-      end
-
-      def _eql?(other)
-        other.class == self.class && other.members.eql?(self.members)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/selector/sequence.rb

@@ -1,233 +0,0 @@
-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 => Selector::Sequence}]
-      #   The extensions to perform on 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, 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, 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|
-              subweave(before, current).map {|seqs| seqs + last_current}
-            end, 1)
-          return befores if afters.empty?
-        end
-      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`.
-      #
-      # @overload def subweave(seq1, seq2)
-      # @param seq1 [Array<SimpleSequence or String>]
-      # @param seq2 [Array<SimpleSequence or String>]
-      # @return [Array<Array<SimpleSequence or String>>]
-      def subweave(seq1, seq2, cache = {})
-        return [seq2] if seq1.empty?
-        return [seq1] if seq2.empty?
-
-        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 = []
-        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
-
-      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
-
-      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
-
-      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/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/selector/simple.rb

@@ -1,113 +0,0 @@
-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
-
-      # 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.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