haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/lib/sass/selector/simple_sequence.rb

@@ -1,134 +0,0 @@
-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)
-      # @param extends [{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`.
-      # @see CommaSequence#do_extend
-      def do_extend(extends, seen = Set.new)
-        extends.get(members.to_set).map do |seq, sels|
-          # If A {@extend B} and C {...},
-          # seq is A, sels is B, and self is C
-
-          self_without_sel = self.members - sels
-          next unless unified = seq.members.last.unify(self_without_sel)
-          [sels, seq.members[0...-1] + [unified]]
-        end.compact.map do |sels, seq|
-          seq = Sequence.new(seq)
-          seen.include?(sels) ? [] : seq.do_extend(extends, 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 _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

data/vendor/sass/lib/sass/shared.rb

@@ -1,78 +0,0 @@
-require 'strscan'
-
-module Sass
-  # This module contains functionality that's shared between Haml and Sass.
-  module Shared
-    extend self
-
-    # Scans through a string looking for the interoplation-opening `#{`
-    # and, when it's found, yields the scanner to the calling code
-    # so it can handle it properly.
-    #
-    # The scanner will have any backslashes immediately in front of the `#{`
-    # as the second capture group (`scan[2]`),
-    # and the text prior to that as the first (`scan[1]`).
-    #
-    # @yieldparam scan [StringScanner] The scanner scanning through the string
-    # @return [String] The text remaining in the scanner after all `#{`s have been processed
-    def handle_interpolation(str)
-      scan = StringScanner.new(str)
-      yield scan while scan.scan(/(.*?)(\\*)\#\{/m)
-      scan.rest
-    end
-
-    # Moves a scanner through a balanced pair of characters.
-    # For example:
-    #
-    #     Foo (Bar (Baz bang) bop) (Bang (bop bip))
-    #     ^                       ^
-    #     from                    to
-    #
-    # @param scanner [StringScanner] The string scanner to move
-    # @param start [Character] The character opening the balanced pair.
-    #   A `Fixnum` in 1.8, a `String` in 1.9
-    # @param finish [Character] The character closing the balanced pair.
-    #   A `Fixnum` in 1.8, a `String` in 1.9
-    # @param count [Fixnum] The number of opening characters matched
-    #   before calling this method
-    # @return [(String, String)] The string matched within the balanced pair
-    #   and the rest of the string.
-    #   `["Foo (Bar (Baz bang) bop)", " (Bang (bop bip))"]` in the example above.
-    def balance(scanner, start, finish, count = 0)
-      str = ''
-      scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
-      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
-      while scanner.scan(regexp)
-        str << scanner.matched
-        count += 1 if scanner.matched[-1] == start
-        count -= 1 if scanner.matched[-1] == finish
-        return [str.strip, scanner.rest] if count == 0
-      end
-    end
-
-    # Formats a string for use in error messages about indentation.
-    #
-    # @param indentation [String] The string used for indentation
-    # @param was [Boolean] Whether or not to add `"was"` or `"were"`
-    #   (depending on how many characters were in `indentation`)
-    # @return [String] The name of the indentation (e.g. `"12 spaces"`, `"1 tab"`)
-    def human_indentation(indentation, was = false)
-      if !indentation.include?(?\t)
-        noun = 'space'
-      elsif !indentation.include?(?\s)
-        noun = 'tab'
-      else
-        return indentation.inspect + (was ? ' was' : '')
-      end
-
-      singular = indentation.length == 1
-      if was
-        was = singular ? ' was' : ' were'
-      else
-        was = ''
-      end
-
-      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/charset_node.rb

@@ -1,22 +0,0 @@
-module Sass::Tree
-  # A static node representing an unproccessed Sass `@charset` directive.
-  #
-  # @see Sass::Tree
-  class CharsetNode < Node
-    # The name of the charset.
-    #
-    # @return [String]
-    attr_accessor :name
-
-    # @param name [String] see \{#name}
-    def initialize(name)
-      @name = name
-      super()
-    end
-
-    # @see Node#invisible?
-    def invisible?
-      !Sass::Util.ruby1_8?
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/comment_node.rb

@@ -1,90 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node representing a Sass comment (silent or loud).
-  #
-  # @see Sass::Tree
-  class CommentNode < Node
-    # The text of the comment, not including `/*` and `*/`.
-    # Interspersed with {Sass::Script::Node}s representing `#{}`-interpolation
-    # if this is a loud comment.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :value
-
-    # The text of the comment
-    # after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_value
-
-    # Whether the comment is loud.
-    #
-    # Loud comments start with ! and force the comment to be generated
-    # irrespective of compilation settings or the comment syntax used.
-    #
-    # @return [Boolean]
-    attr_accessor :loud
-
-    # Whether or not the comment is silent (that is, doesn't output to CSS).
-    #
-    # @return [Boolean]
-    attr_accessor :silent
-
-    # @param value [Array<String, Sass::Script::Node>] See \{#value}
-    # @param silent [Boolean] See \{#silent}
-    # @param loud [Boolean] See \{#loud}
-    def initialize(value, silent, loud)
-      @value = Sass::Util.with_extracted_values(value) {|str| normalize_indentation str}
-      @silent = silent
-      @loud = loud
-      super()
-    end
-
-    # Compares the contents of two comments.
-    #
-    # @param other [Object] The object to compare with
-    # @return [Boolean] Whether or not this node and the other object
-    #   are the same
-    def ==(other)
-      self.class == other.class && value == other.value && silent == other.silent && loud == other.loud
-    end
-
-    # Returns `true` if this is a silent comment
-    # or the current style doesn't render comments.
-    #
-    # Comments starting with ! are never invisible (and the ! is removed from the output.)
-    #
-    # @return [Boolean]
-    def invisible?
-      if @loud
-        return false
-      else
-        @silent || (style == :compressed)
-      end
-    end
-
-    # Returns the number of lines in the comment.
-    #
-    # @return [Fixnum]
-    def lines
-      @value.inject(0) do |s, e|
-        next s + e.count("\n") if e.is_a?(String)
-        next s
-      end
-    end
-
-    private
-
-    def normalize_indentation(str)
-      pre = str.split("\n").inject(str[/^[ \t]*/].split("")) do |pre, line|
-        line[/^[ \t]*/].split("").zip(pre).inject([]) do |arr, (a, b)|
-          break arr if a != b
-          arr + [a]
-        end
-      end.join
-      str.gsub(/^#{pre}/, '')
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/debug_node.rb

@@ -1,18 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a Sass `@debug` statement.
-    #
-    # @see Sass::Tree
-    class DebugNode < Node
-      # The expression to print.
-      # @return [Script::Node] 
-      attr_accessor :expr
-
-      # @param expr [Script::Node] The expression to print
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/directive_node.rb

@@ -1,23 +0,0 @@
-module Sass::Tree
-  # A static node representing an unproccessed Sass `@`-directive.
-  # Directives known to Sass, like `@for` and `@debug`,
-  # are handled by their own nodes;
-  # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
-  #
-  # `@import` and `@charset` are special cases;
-  # they become {ImportNode}s and {CharsetNode}s, respectively.
-  #
-  # @see Sass::Tree
-  class DirectiveNode < Node
-    # The text of the directive, `@` and all.
-    #
-    # @return [String]
-    attr_accessor :value
-
-    # @param value [String] See \{#value}
-    def initialize(value)
-      @value = value
-      super()
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/each_node.rb

@@ -1,24 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A dynamic node representing a Sass `@each` loop.
-  #
-  # @see Sass::Tree
-  class EachNode < Node
-    # The name of the loop variable.
-    # @return [String]
-    attr_reader :var
-
-    # The parse tree for the list.
-    # @param [Script::Node]
-    attr_accessor :list
-
-    # @param var [String] The name of the loop variable
-    # @param list [Script::Node] The parse tree for the list
-    def initialize(var, list)
-      @var = var
-      @list = list
-      super()
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/extend_node.rb

@@ -1,29 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node reprenting an `@extend` directive.
-  #
-  # @see Sass::Tree
-  class ExtendNode < Node
-    # The parsed selector after interpolation has been resolved.
-    # Only set once {Tree::Visitors::Perform} has been run.
-    #
-    # @return [Selector::CommaSequence]
-    attr_accessor :resolved_selector
-
-    # The CSS selector to extend, interspersed with {Sass::Script::Node}s
-    # representing `#{}`-interpolation.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :selector
-
-    # @param selector [Array<String, Sass::Script::Node>]
-    #   The CSS selector to extend,
-    #   interspersed with {Sass::Script::Node}s
-    #   representing `#{}`-interpolation.
-    def initialize(selector)
-      @selector = selector
-      super()
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/for_node.rb

@@ -1,36 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A dynamic node representing a Sass `@for` loop.
-  #
-  # @see Sass::Tree
-  class ForNode < Node
-    # The name of the loop variable.
-    # @return [String]
-    attr_reader :var
-
-    # The parse tree for the initial expression.
-    # @return [Script::Node]
-    attr_accessor :from
-
-    # The parse tree for the final expression.
-    # @return [Script::Node]
-    attr_accessor :to
-
-    # Whether to include `to` in the loop or stop just before.
-    # @return [Boolean]
-    attr_reader :exclusive
-
-    # @param var [String] See \{#var}
-    # @param from [Script::Node] See \{#from}
-    # @param to [Script::Node] See \{#to}
-    # @param exclusive [Boolean] See \{#exclusive}
-    def initialize(var, from, to, exclusive)
-      @var = var
-      @from = from
-      @to = to
-      @exclusive = exclusive
-      super()
-    end
-  end
-end