sass 3.1.21 → 3.2.0.alpha.3

data/lib/sass/scss/rx.rb

@@ -51,8 +51,6 @@ module Sass
       UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/
       s = if Sass::Util.ruby1_8?
             '\200-\377'
-          elsif Sass::Util.macruby?
-            '\u0080-\uD7FF\uE000-\uFFFD\U00010000-\U0010FFFF'
           else
             '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'
           end
@@ -109,17 +107,11 @@ module Sass
       TILDE = /#{W}~/
       NOT = quote(":not(", Regexp::IGNORECASE)
 
-      # Defined in https://developer.mozilla.org/en/CSS/@-moz-document as a
-      # non-standard version of http://www.w3.org/TR/css3-conditional/
-      URL_PREFIX = /url-prefix\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
-      DOMAIN = /domain\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
-
       # Custom
       HEXCOLOR = /\#[0-9a-fA-F]+/
       INTERP_START = /#\{/
       MOZ_ANY = quote(":-moz-any(", Regexp::IGNORECASE)
 
-      IDENT_HYPHEN_INTERP = /-(#\{)/
       STRING1_NOINTERP = /\"((?:[^\n\r\f\\"#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\"/
       STRING2_NOINTERP = /\'((?:[^\n\r\f\\'#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\'/
       STRING_NOINTERP = /#{STRING1_NOINTERP}|#{STRING2_NOINTERP}/
@@ -127,13 +119,9 @@ module Sass
       # We could use it for 1.9 only, but I don't want to introduce a cross-version
       # behavior difference.
       # In any case, almost all CSS idents will be matched by this.
-      #
-      # We explicitly avoid parsing newlines or values/selectors longer than
-      # about 50 characters. This mitigates the problem of exponential parsing
-      # time when a value has a long string of valid, parsable content followed
-      # by something invalid.
-      STATIC_VALUE = /(-?#{NMSTART}|#{STRING_NOINTERP}|[ \t](?!%)|#[a-f0-9]|[,%]|#{NUM}|\!important){0,50}([;}])/i
-      STATIC_SELECTOR = /(#{NMCHAR}|[ \t]|[,>+*]|[:#.]#{NMSTART}){0,50}([{])/i
+      STATIC_VALUE = /(-?#{NMSTART}|#{STRING_NOINTERP}|\s(?!%)|#[a-f0-9]|[,%]|#{NUM}|\!important)+(?=[;}])/i
+
+      STATIC_SELECTOR = /(#{NMCHAR}|\s|[,>+*]|[:#.]#{NMSTART})+(?=[{])/i
     end
   end
 end

data/lib/sass/scss/static_parser.rb

@@ -13,12 +13,12 @@ module Sass
       #   Used for error reporting.
       # @return [Selector::CommaSequence] The parsed selector
       # @raise [Sass::SyntaxError] if there's a syntax error in the selector
-      def parse_selector
+      def parse_selector(filename)
         init_scanner!
         seq = expr!(:selector_comma_sequence)
         expected("selector") unless @scanner.eos?
         seq.line = @line
-        seq.filename = @filename
+        seq.filename = filename
         seq
       end
 
@@ -32,7 +32,7 @@ module Sass
       def use_css_import?; true; end
 
       def special_directive(name)
-        return unless %w[media import charset -moz-document].include?(name)
+        return unless  %w[media import charset].include?(name)
         super
       end
     end

data/lib/sass/selector.rb

@@ -287,13 +287,6 @@ module Sass
       # @return [Symbol]
       attr_reader :type
 
-      # Some psuedo-class-syntax selectors (`:after` and `:before)
-      # are actually considered pseudo-elements
-      # and must be at the end of the selector to function properly.
-      #
-      # @return [Array<String>]
-      FINAL_SELECTORS = %w[after before]
-
       # The name of the selector.
       #
       # @return [Array<String, Sass::Script::Node>]
@@ -319,10 +312,6 @@ module Sass
         @arg = arg
       end
 
-      def final?
-        type == :class && FINAL_SELECTORS.include?(name.first)
-      end
-
       # @see Selector#to_a
       def to_a
         res = [@type == :class ? ":" : "::"] + @name
@@ -330,8 +319,8 @@ module Sass
         res
       end
 
-      # Returns `nil` if this is a pseudoelement selector
-      # and `sels` contains a pseudoelement selector different than this one.
+      # Returns `nil` if this is a pseudoclass selector
+      # and `sels` contains a pseudoclass selector different than this one.
       #
       # @see Selector#unify
       def unify(sels)
@@ -339,7 +328,6 @@ module Sass
           sel.is_a?(Pseudo) && sel.type == :element &&
             (sel.name != self.name || sel.arg != self.arg)
         end
-        return sels + [self] if final?
         super
       end
     end
@@ -358,7 +346,7 @@ module Sass
       attr_reader :selector
 
       # @param [String] The name of the pseudoclass
-      # @param [Selector::CommaSequence] The selector argument
+      # @param [Selector::Sequence] The selector argument
       def initialize(name, selector)
         @name = name
         @selector = selector

data/lib/sass/selector/abstract_sequence.rb

@@ -2,9 +2,8 @@ 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=`, as well as a `to_a`
-    # method that returns an array of strings and script nodes.
+    # 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.
       #
@@ -58,14 +57,6 @@ module Sass
         other.class == self.class && other.hash == self.hash && _eql?(other)
       end
       alias_method :==, :eql?
-
-      # Converts the selector into a string. This is the standard selector
-      # string, along with any SassScript interpolation that may exist.
-      #
-      # @return [String]
-      def to_s
-        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
-      end
     end
   end
 end

data/lib/sass/selector/comma_sequence.rb

@@ -44,17 +44,12 @@ module Sass
       # @todo Link this to the reference documentation on `@extend`
       #   when such a thing exists.
       #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
-      #                                       Sass::Tree::Visitors::Cssize::Extend}]
+      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
       #   The extensions to perform on this selector
-      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
-      #   The directives containing this selector.
       # @return [CommaSequence] A copy of this selector,
       #   with extensions made according to `extends`
-      def do_extend(extends, parent_directives)
-        CommaSequence.new(members.map do |seq|
-            seq.do_extend(extends, parent_directives)
-          end.flatten)
+      def do_extend(extends)
+        CommaSequence.new(members.map {|seq| seq.do_extend(extends)}.flatten)
       end
 
       # Returns a string representation of the sequence.

data/lib/sass/selector/sequence.rb

@@ -47,15 +47,15 @@ module Sass
       # @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.dup
+        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
-          old_members, members = members, []
+          members = []
           members << nl if nl
           members << SimpleSequence.new([Parent.new])
-          members += old_members
+          members += @members
         end
 
         Sequence.new(
@@ -69,19 +69,16 @@ module Sass
       # (which should come from {Sass::Tree::Visitors::Cssize}).
       #
       # @overload def do_extend(extends)
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
-      #                                       Sass::Tree::Visitors::Cssize::Extend}]
+      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
       #   The extensions to perform on this selector
-      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
-      #   The directives containing 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, parent_directives, seen = Set.new)
+      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, parent_directives, seen)
+            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
@@ -137,11 +134,10 @@ module Sass
             last_current.unshift(current.pop)
           end
           befores = Sass::Util.flatten(befores.map do |before|
-              next [] unless sub = subweave(before, current)
-              sub.map {|seqs| seqs + last_current}
+              subweave(before, current).map {|seqs| seqs + last_current}
             end, 1)
+          return befores if afters.empty?
         end
-        return befores
       end
 
       # This interweaves two lists of selectors,
@@ -153,14 +149,14 @@ module Sass
       # `.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)
+      def subweave(seq1, seq2, cache = {})
         return [seq2] if seq1.empty?
         return [seq1] if seq2.empty?
 
-        return unless init = merge_initial_ops(seq1, seq2)
         seq1 = group_selectors(seq1)
         seq2 = group_selectors(seq2)
         lcs = Sass::Util.lcs(seq2, seq1) do |s1, s2|
@@ -170,7 +166,7 @@ module Sass
           next s1 if subweave_superselector?(s2, s1)
         end
 
-        diff = [[init]]
+        diff = []
         until lcs.empty?
           diff << chunks(seq1, seq2) {|s| subweave_superselector?(s.first, lcs.first)} << [lcs.shift]
           seq1.shift
@@ -182,50 +178,6 @@ module Sass
         Sass::Util.paths(diff).map {|p| p.flatten}
       end
 
-      # Extracts initial selector operators (`"+"`, `">"`, `"~"`, and `"\n"`)
-      # from two sequences and merges them together into a single array of
-      # selector operators.
-      #
-      # @param seq1 [Array<SimpleSequence or String>]
-      # @param seq2 [Array<SimpleSequence or String>]
-      # @return [Array<String>, nil] If there are no operators in the merged
-      #   sequence, this will be the empty array. If the operators cannot be
-      #   merged, this will be nil.
-      def merge_initial_ops(seq1, seq2)
-        ops1, ops2 = [], []
-        ops1 << seq1.shift while seq1.first.is_a?(String)
-        ops2 << seq2.shift while seq2.first.is_a?(String)
-
-        newline = false
-        newline ||= !!ops1.shift if ops1.first == "\n"
-        newline ||= !!ops2.shift if ops2.first == "\n"
-
-        # If neither sequence is a subsequence of the other, they cannot be
-        # merged successfully
-        lcs = Sass::Util.lcs(ops1, ops2)
-        return unless lcs == ops1 || lcs == ops2
-        return (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
-      end
-
-      # Takes initial subsequences of `seq1` and `seq2` and returns all
-      # orderings of those subsequences. The initial subsequences are determined
-      # by a block.
-      #
-      # Destructively removes the initial subsequences of `seq1` and `seq2`.
-      #
-      # For example, given `(A B C | D E)` and `(1 2 | 3 4 5)` (with `|`
-      # denoting the boundary of the initial subsequence), this would return
-      # `[(A B C 1 2), (1 2 A B C)]`. The sequences would then be `(D E)` and
-      # `(3 4 5)`.
-      #
-      # @param seq1 [Array]
-      # @param seq2 [Array]
-      # @yield [a] Used to determine when to cut off the initial subsequences.
-      #   Called repeatedly for each sequence until it returns true.
-      # @yieldparam a [Array] A final subsequence of one input sequence after
-      #   cutting off some initial subsequence.
-      # @yieldreturn [Boolean] Whether or not to cut off the initial subsequence
-      #   here.
       def chunks(seq1, seq2)
         chunk1 = []
         chunk1 << seq1.shift until yield seq1
@@ -237,15 +189,6 @@ module Sass
         [chunk1 + chunk2, chunk2 + chunk1]
       end
 
-      # Groups a sequence into subsequences. The subsequences are determined by
-      # strings; adjacent non-string elements will be put into separate groups,
-      # but any element adjacent to a string will be grouped with that string.
-      #
-      # For example, `(A B "C" D E "F" G "H" "I" J)` will become `[(A) (B "C" D)
-      # (E "F" G "H" "I" J)]`.
-      #
-      # @param seq [Array]
-      # @return [Array<Array>]
       def group_selectors(seq)
         newseq = []
         tail = seq.dup
@@ -259,12 +202,6 @@ module Sass
         return newseq
       end
 
-      # Given two sequences of simple selectors, returns whether `sseq1` is a
-      # superselector of `sseq2`.
-      #
-      # @param sseq1 [Array<SimpleSelector or String>]
-      # @param sseq2 [Array<SimpleSelector or String>]
-      # @return [Boolean]
       def subweave_superselector?(sseq1, sseq2)
         if sseq1.size > 1
           # More complex selectors are never superselectors of less complex ones

data/lib/sass/selector/simple.rb

@@ -33,12 +33,6 @@ module Sass
         to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
 
-      # @see \{#inspect}
-      # @return [String]
-      def to_s
-        inspect
-      end
-
       # Returns a hash code for this selector object.
       #
       # By default, this is based on the value of \{#to\_a},
@@ -85,7 +79,7 @@ module Sass
         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.final? || sels.last.type == :element)}
+            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

data/lib/sass/selector/simple_sequence.rb

@@ -54,28 +54,23 @@ module Sass
       # 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, parent_directives)
-      # @param extends [{Selector::Simple =>
-      #                  Sass::Tree::Visitors::Cssize::Extend}]
+      # @overload def do_extend(extends)
+      # @param extends [{Selector::Simple => Selector::Sequence}]
       #   The extensions to perform on this selector
-      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
-      #   The directives containing this selector.
       # @return [Array<Sequence>] A list of selectors generated
       #   by extending this selector with `extends`.
       # @see CommaSequence#do_extend
-      def do_extend(extends, parent_directives, seen = Set.new)
-        extends.get(members.to_set).map do |ex, sels|
+      def do_extend(extends, seen = Set.new)
+        extends.get(members.to_set).map do |seq, sels|
           # If A {@extend B} and C {...},
-          # ex.extender is A, sels is B, and self is C
+          # seq is A, sels is B, and self is C
 
           self_without_sel = self.members - sels
-          next unless unified = ex.extender.members.last.unify(self_without_sel)
-          next unless check_directives_match!(ex, parent_directives)
-          [sels, ex.extender.members[0...-1] + [unified]]
+          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)
-          next [] if seen.include?(sels)
-          seq.do_extend(extends, parent_directives, seen + [sels])
+          seen.include?(sels) ? [] : seq.do_extend(extends, seen + [sels])
         end.flatten.uniq
       end
 
@@ -127,21 +122,6 @@ module Sass
 
       private
 
-      def check_directives_match!(extend, parent_directives)
-        dirs1 = extend.directives.map {|d| d.value}
-        dirs2 = parent_directives.map {|d| d.value}
-        return true if Sass::Util.subsequence?(dirs1, dirs2)
-
-        Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING on line #{extend.node.line}#{" of #{extend.node.filename}" if extend.node.filename}:
-  @extending an outer selector from within #{extend.directives.last.name} is deprecated.
-  You may only @extend selectors within the same directive.
-  This will be an error in Sass 3.3.
-  It can only work once @extend is supported natively in the browser.
-WARNING
-        return false
-      end
-
       def _hash
         [base, Sass::Util.set_hash(rest)].hash
       end

data/lib/sass/shared.rb

@@ -1,3 +1,5 @@
+require 'strscan'
+
 module Sass
   # This module contains functionality that's shared between Haml and Sass.
   module Shared
@@ -14,8 +16,8 @@ module Sass
     # @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 = Sass::Util::MultibyteStringScanner.new(str)
-      yield scan while scan.scan(/(.*?)(\\*)\#\{/m)
+      scan = StringScanner.new(str)
+      yield scan while scan.scan(/(.*?)(\\*)\#\{/)
       scan.rest
     end
 
@@ -38,7 +40,7 @@ module Sass
     #   `["Foo (Bar (Baz bang) bop)", " (Bang (bop bip))"]` in the example above.
     def balance(scanner, start, finish, count = 0)
       str = ''
-      scanner = Sass::Util::MultibyteStringScanner.new(scanner) unless scanner.is_a? StringScanner
+      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

data/lib/sass/tree/comment_node.rb

@@ -6,18 +6,9 @@ module Sass::Tree
   # @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
+    attr_accessor :value
 
     # Whether the comment is loud.
     #
@@ -32,13 +23,14 @@ module Sass::Tree
     # @return [Boolean]
     attr_accessor :silent
 
-    # @param value [Array<String, Sass::Script::Node>] See \{#value}
+    # @param value [String] 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}
+    def initialize(value, silent)
+      @lines = []
       @silent = silent
-      @loud = loud
+      @value = normalize_indentation value
+      @loud = @value =~ %r{^(/[\/\*])?!}
+      @value.sub!("#{$1}!", $1.to_s) if @loud
       super()
     end
 
@@ -48,7 +40,7 @@ module Sass::Tree
     # @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
+      self.class == other.class && value == other.value && silent == other.silent
     end
 
     # Returns `true` if this is a silent comment
@@ -65,14 +57,9 @@ module Sass::Tree
       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
+    # Returns whether this comment should be interpolated for dynamic comment generation.
+    def evaluated?
+      @loud
     end
 
     private
@@ -81,7 +68,7 @@ module Sass::Tree
       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
+          arr + [a]
         end
       end.join
       str.gsub(/^#{pre}/, '')