haml_ejs 0.0.1

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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,78 @@
+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/charset_node.rb

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,77 @@
+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 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 [String] See \{#value}
+    # @param silent [Boolean] See \{#silent}
+    def initialize(value, silent)
+      @lines = []
+      @silent = silent
+      @value = normalize_indentation value
+      @loud = @value =~ %r{^(/[\/\*])?!}
+      @value.sub!("#{$1}!", $1.to_s) if @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
+    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 whether this comment should be interpolated for dynamic comment generation.
+    def evaluated?
+      @loud
+    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

@@ -0,0 +1,18 @@
+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_reader :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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,24 @@
+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_reader :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

@@ -0,0 +1,29 @@
+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_reader :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

@@ -0,0 +1,36 @@
+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_reader :from
+
+    # The parse tree for the final expression.
+    # @return [Script::Node]
+    attr_reader :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