sass 3.1.0.alpha.2

data/lib/sass/selector/simple_sequence.rb

@@ -0,0 +1,135 @@
+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/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/lib/sass/tree/comment_node.rb

@@ -0,0 +1,128 @@
+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/lib/sass/tree/debug_node.rb

@@ -0,0 +1,36 @@
+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/lib/sass/tree/directive_node.rb

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