haml 3.0.21 → 3.0.22

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

@@ -1,135 +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 be populated via {Sass::Tree::Node#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(/(.*?)(\\*)\#\{/)
-      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/comment_node.rb

@@ -1,128 +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 `*/`.
-    #
-    # @return [String]
-    attr_accessor :value
-
-    # Whether or not the comment is silent (that is, doesn't output to CSS).
-    #
-    # @return [Boolean]
-    attr_accessor :silent
-
-    # @param value [String] See \{#value}
-    # @param silent [Boolean] See \{#silent}
-    def initialize(value, silent)
-      @lines = []
-      @value = normalize_indentation value
-      @silent = silent
-      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
-    end
-
-    # Returns `true` if this is a silent comment
-    # or the current style doesn't render comments.
-    #
-    # @return [Boolean]
-    def invisible?
-      style == :compressed || @silent
-    end
-
-    # @see Node#to_sass
-    def to_sass(tabs, opts = {})
-      content = value.gsub(/\*\/$/, '').rstrip
-      if content =~ /\A[ \t]/
-        # Re-indent SCSS comments like this:
-        #     /* foo
-        #   bar
-        #       baz */
-        content.gsub!(/^/, '   ')
-        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
-      end
-
-      content =
-        unless content.include?("\n")
-          content
-        else
-          content.gsub!(/\n( \*|\/\/)/, "\n  ")
-          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
-          sep = silent ? "\n//" : "\n *"
-          if spaces >= 2
-            content.gsub(/\n  /, sep)
-          else
-            content.gsub(/\n#{' ' * spaces}/, sep)
-          end
-        end
-
-      content.gsub!(/\A\/\*/, '//') if silent
-      content.gsub!(/^/, '  ' * tabs)
-      content.rstrip + "\n"
-    end
-
-    # @see Node#to_scss
-    def to_scss(tabs, opts = {})
-      spaces = ('  ' * [tabs - value[/^ */].size, 0].max)
-      if silent
-        value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
-      else
-        value
-      end.gsub(/^/, spaces) + "\n"
-    end
-
-    protected
-
-    # Computes the CSS for the comment.
-    #
-    # Returns `nil` if this is a silent comment
-    # or the current style doesn't render comments.
-    #
-    # @overload to_s(tabs = 0)
-    # @param tabs [Fixnum] The level of indentation for the CSS
-    # @return [String, nil] The resulting CSS
-    # @see #invisible?
-    def _to_s(tabs = 0, _ = nil)
-      return if invisible?
-      spaces = ('  ' * [tabs - 1 - value[/^ */].size, 0].max)
-
-      content = value.gsub(/^/, spaces)
-      content.gsub!(/\n +(\* *(?!\/))?/, ' ') if style == :compact
-      content
-    end
-
-    # Removes this node from the tree if it's a silent comment.
-    #
-    # @param environment [Sass::Environment] The lexical environment containing
-    #   variable and mixin values
-    # @return [Tree::Node, Array<Tree::Node>] The resulting static nodes
-    # @see Sass::Tree
-    def _perform(environment)
-      return [] if @silent
-      self
-    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,36 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a Sass `@debug` statement.
-    #
-    # @see Sass::Tree
-    class DebugNode < Node
-      # @param expr [Script::Node] The expression to print
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-
-      protected
-
-      # @see Node#to_src
-      def to_src(tabs, opts, fmt)
-        "#{'  ' * tabs}@debug #{@expr.to_sass(opts)}#{semi fmt}\n"
-      end
-
-      # Prints the expression to STDERR.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      def _perform(environment)
-        res = @expr.perform(environment)
-        res = res.value if res.is_a?(Sass::Script::String)
-        if filename
-          $stderr.puts "#{filename}:#{line} DEBUG: #{res}"
-        else
-          $stderr.puts "Line #{line} DEBUG: #{res}"
-        end
-        []
-      end
-    end
-  end
-end

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

@@ -1,75 +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` is a bit of a weird case;
-  # it becomes an {ImportNode}.
-  #
-  # @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
-
-    protected
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      res = "#{'  ' * tabs}#{value}"
-      return res + "#{semi fmt}\n" unless has_children
-      res + children_to_src(tabs, opts, fmt) + "\n"
-    end
-
-    # Computes the CSS for the directive.
-    #
-    # @param tabs [Fixnum] The level of indentation for the CSS
-    # @return [String] The resulting CSS
-    def _to_s(tabs)
-      return value + ";" unless has_children
-      return value + " {}" if children.empty?
-      result = if style == :compressed
-                 "#{value}{"
-               else
-                 "#{'  ' * (tabs - 1)}#{value} {" + (style == :compact ? ' ' : "\n")
-               end
-      was_prop = false
-      first = true
-      children.each do |child|
-        next if child.invisible?
-        if style == :compact
-          if child.is_a?(PropNode)
-            result << "#{child.to_s(first || was_prop ? 1 : tabs + 1)} "
-          else
-            if was_prop
-              result[-1] = "\n"
-            end
-            rendered = child.to_s(tabs + 1).dup
-            rendered = rendered.lstrip if first
-            result << rendered.rstrip + "\n"
-          end
-          was_prop = child.is_a?(PropNode)
-          first = false
-        elsif style == :compressed
-          result << (was_prop ? ";#{child.to_s(1)}" : child.to_s(1))
-          was_prop = child.is_a?(PropNode)
-        else
-          result << child.to_s(tabs + 1) + "\n"
-        end
-      end
-      result.rstrip + if style == :compressed
-                        "}"
-                      else
-                        (style == :expanded ? "\n" : " ") + "}\n"
-                      end
-    end
-  end
-end