sass 3.1.12 → 3.1.13

data/VERSION

@@ -1 +1 @@
-3.1.12
+3.1.13

data/lib/sass/cache_stores/filesystem.rb

@@ -53,6 +53,7 @@ module Sass
       # @param key [String]
       # @return [String] The path to the cache file.
       def path_to(key)
+        key = key.gsub(/[<>:\\|?*%]/) {|c| "%%%03d" % Sass::Util.ord(c)}
         File.join(cache_location, key)
       end
     end

data/lib/sass/css.rb

@@ -1,7 +1,6 @@
 require File.dirname(__FILE__) + '/../sass'
 require 'sass/tree/node'
 require 'sass/scss/css_parser'
-require 'strscan'
 
 module Sass
   # This class converts CSS documents into Sass or SCSS templates.

data/lib/sass/engine.rb

@@ -1,4 +1,3 @@
-require 'strscan'
 require 'set'
 require 'digest/sha1'
 require 'sass/cache_stores'
@@ -219,7 +218,7 @@ module Sass
     # If you're compiling a single Sass file from the filesystem,
     # use \{Sass::Engine.for\_file}.
     # If you're compiling multiple files from the filesystem,
-    # use {Sass::Plugin.
+    # use {Sass::Plugin}.
     #
     # @param template [String] The Sass template.
     #   This template can be encoded using any encoding
@@ -565,7 +564,7 @@ WARNING
     end
 
     def parse_property_or_rule(line)
-      scanner = StringScanner.new(line.text)
+      scanner = Sass::Util::MultibyteStringScanner.new(line.text)
       hack_char = scanner.scan(/[:\*\.]|\#(?!\{)/)
       parser = Sass::SCSS::SassParser.new(scanner, @options[:filename], @line)
 
@@ -749,7 +748,7 @@ WARNING
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.",
         :line => @line + 1) unless line.children.empty?
 
-      scanner = StringScanner.new(value)
+      scanner = Sass::Util::MultibyteStringScanner.new(value)
       values = []
 
       loop do
@@ -783,7 +782,7 @@ WARNING
       elsif uri
         Tree::DirectiveNode.new("@import #{uri}")
       elsif val =~ /^http:\/\//
-        Tree::DirectiveNode.new("@import url(#{val})")
+        Tree::DirectiveNode.new("@import #{str}")
       else
         Tree::ImportNode.new(val)
       end

data/lib/sass/script.rb

@@ -1,4 +1,3 @@
-require 'strscan'
 require 'sass/script/node'
 require 'sass/script/variable'
 require 'sass/script/funcall'

data/lib/sass/script/funcall.rb

@@ -36,7 +36,7 @@ module Sass
       # @return [String] A string representation of the function call
       def inspect
         args = @args.map {|a| a.inspect}.join(', ')
-        keywords = @keywords.sort_by {|k, v| k}.
+        keywords = Sass::Util.hash_to_a(@keywords).
             map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
         "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
@@ -44,7 +44,7 @@ module Sass
       # @see Node#to_sass
       def to_sass(opts = {})
         args = @args.map {|a| a.to_sass(opts)}.join(', ')
-        keywords = @keywords.sort_by {|k, v| k}.
+        keywords = Sass::Util.hash_to_a(@keywords).
           map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
         "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end

data/lib/sass/script/lexer.rb

@@ -1,7 +1,5 @@
 require 'sass/scss/rx'
 
-require 'strscan'
-
 module Sass
   module Script
     # The lexical analyzer for SassScript.
@@ -126,7 +124,7 @@ module Sass
       # @param options [{Symbol => Object}] An options hash;
       #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
       def initialize(str, line, offset, options)
-        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
+        @scanner = str.is_a?(StringScanner) ? str : Sass::Util::MultibyteStringScanner.new(str)
         @line = line
         @offset = offset
         @options = options

data/lib/sass/script/literal.rb

@@ -55,26 +55,6 @@ The #options attribute is not set on this #{self.class}.
 MSG
     end
 
-    # The SassScript `and` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Literal] The result of a logical and:
-    #   `other` if this literal isn't a false {Bool},
-    #   and this literal otherwise
-    def and(other)
-      to_bool ? other : self
-    end
-
-    # The SassScript `or` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Literal] The result of the logical or:
-    #   this literal if it isn't a false {Bool},
-    #   and `other` otherwise
-    def or(other)
-      to_bool ? self : other
-    end
-
     # The SassScript `==` operation.
     # **Note that this returns a {Sass::Script::Bool} object,
     # not a Ruby boolean**.

data/lib/sass/script/operation.rb

@@ -72,6 +72,14 @@ module Sass::Script
     # @raise [Sass::SyntaxError] if the operation is undefined for the operands
     def _perform(environment)
       literal1 = @operand1.perform(environment)
+
+      # Special-case :and and :or to support short-circuiting.
+      if @operator == :and
+        return literal1.to_bool ? @operand2.perform(environment) : literal1
+      elsif @operator == :or
+        return literal1.to_bool ? literal1 : @operand2.perform(environment)
+      end
+
       literal2 = @operand2.perform(environment)
 
       begin

data/lib/sass/scss/parser.rb

@@ -1,4 +1,3 @@
-require 'strscan'
 require 'set'
 
 module Sass
@@ -50,7 +49,7 @@ module Sass
           if @template.is_a?(StringScanner)
             @template
           else
-            StringScanner.new(@template.gsub("\r", ""))
+            Sass::Util::MultibyteStringScanner.new(@template.gsub("\r", ""))
           end
       end
 
@@ -906,7 +905,7 @@ MESSAGE
         if @throw_err
           throw :_sass_parser_error, err
         else
-          @scanner = StringScanner.new(@scanner.string)
+          @scanner = Sass::Util::MultibyteStringScanner.new(@scanner.string)
           @scanner.pos = err[:pos]
           @line = err[:line]
           @expected = err[:expected]

data/lib/sass/selector.rb

@@ -287,6 +287,13 @@ 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>]
@@ -312,6 +319,10 @@ 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
@@ -319,8 +330,8 @@ module Sass
         res
       end
 
-      # Returns `nil` if this is a pseudoclass selector
-      # and `sels` contains a pseudoclass selector different than this one.
+      # Returns `nil` if this is a pseudoelement selector
+      # and `sels` contains a pseudoelement selector different than this one.
       #
       # @see Selector#unify
       def unify(sels)
@@ -328,6 +339,7 @@ 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
@@ -346,7 +358,7 @@ module Sass
       attr_reader :selector
 
       # @param [String] The name of the pseudoclass
-      # @param [Selector::Sequence] The selector argument
+      # @param [Selector::CommaSequence] The selector argument
       def initialize(name, selector)
         @name = name
         @selector = selector

data/lib/sass/selector/sequence.rb

@@ -134,10 +134,11 @@ module Sass
             last_current.unshift(current.pop)
           end
           befores = Sass::Util.flatten(befores.map do |before|
-              subweave(before, current).map {|seqs| seqs + last_current}
+              next [] unless sub = subweave(before, current)
+              sub.map {|seqs| seqs + last_current}
             end, 1)
-          return befores if afters.empty?
         end
+        return befores
       end
 
       # This interweaves two lists of selectors,
@@ -149,14 +150,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, cache = {})
+      def subweave(seq1, seq2)
         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|
@@ -166,7 +167,7 @@ module Sass
           next s1 if subweave_superselector?(s2, s1)
         end
 
-        diff = []
+        diff = [[init]]
         until lcs.empty?
           diff << chunks(seq1, seq2) {|s| subweave_superselector?(s.first, lcs.first)} << [lcs.shift]
           seq1.shift
@@ -178,6 +179,50 @@ 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
@@ -189,6 +234,15 @@ 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
@@ -202,6 +256,12 @@ 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

@@ -79,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.type == :element}
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.final? || sels.last.type == :element)}
           else
             sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) || sel.is_a?(SelectorPseudoClass)}
           end

data/lib/sass/shared.rb

@@ -1,5 +1,3 @@
-require 'strscan'
-
 module Sass
   # This module contains functionality that's shared between Haml and Sass.
   module Shared
@@ -16,7 +14,7 @@ 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 = StringScanner.new(str)
+      scan = Sass::Util::MultibyteStringScanner.new(str)
       yield scan while scan.scan(/(.*?)(\\*)\#\{/m)
       scan.rest
     end
@@ -40,7 +38,7 @@ module Sass
     #   `["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
+      scanner = Sass::Util::MultibyteStringScanner.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/visitors/convert.rb

@@ -177,7 +177,8 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_mixin(node)
     unless node.args.empty? && node.keywords.empty?
       args = node.args.map {|a| a.to_sass(@options)}.join(", ")
-      keywords = node.keywords.map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
+      keywords = Sass::Util.hash_to_a(node.keywords).
+        map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
       arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
     end
     "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{semi}\n"

data/lib/sass/tree/visitors/cssize.rb

@@ -52,12 +52,26 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   def visit_root(node)
     yield
 
-    # In Ruby 1.9 we can make all @charset nodes invisible
-    # and infer the final @charset from the encoding of the final string.
-    if Sass::Util.ruby1_8? && parent.nil?
-      charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
-      node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
-      node.children.unshift charset if charset
+    if parent.nil?
+      # In Ruby 1.9 we can make all @charset nodes invisible
+      # and infer the final @charset from the encoding of the final string.
+      if Sass::Util.ruby1_8?
+        charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
+        node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
+        node.children.unshift charset if charset
+      end
+
+      imports = Sass::Util.extract!(node.children) do |c|
+        c.is_a?(Sass::Tree::DirectiveNode) && c.value =~ /^@import /i
+      end
+      charset_and_index = Sass::Util.ruby1_8? &&
+        node.children.each_with_index.find {|c, _| c.is_a?(Sass::Tree::CharsetNode)}
+      if charset_and_index
+        index = charset_and_index.last
+        node.children = node.children[0..index] + imports + node.children[index+1..-1]
+      else
+        node.children = imports + node.children
+      end
     end
 
     return node, @extends

data/lib/sass/tree/visitors/perform.rb

@@ -226,6 +226,8 @@ END
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
+    rule = node.rule
+    rule = rule.map {|e| e.is_a?(String) && e != ' ' ? e.strip : e} if node.style == :compressed
     parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.filename, node.line)
     node.parsed_rules ||= parser.parse_selector
     if node.options[:trace_selectors]
@@ -270,6 +272,15 @@ END
 
   def visit_directive(node)
     if node.value['#{']
+      if node.value =~ /^@import (?!url\()/
+        Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
+@import directives using \#{} interpolation will need to use url() in Sass 3.2.
+For example:
+
+  @import url("http://\#{$url}/style.css");
+WARNING
+      end
       node.value = run_interp(Sass::Engine.parse_interp(node.value, node.line, 0, node.options))
     end
     yield

data/lib/sass/tree/visitors/to_css.rb

@@ -67,8 +67,10 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   end
 
   def visit_directive(node)
+    was_in_directive = @in_directive
     return node.value + ";" unless node.has_children
     return node.value + " {}" if node.children.empty?
+    @in_directive = @in_directive || !node.is_a?(Sass::Tree::MediaNode)
     result = if node.style == :compressed
                "#{node.value}{"
              else
@@ -101,6 +103,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
                     else
                       (node.style == :expanded ? "\n" : " ") + "}\n"
                     end
+  ensure
+    @in_directive = was_in_directive
   end
 
   def visit_media(node)
@@ -132,7 +136,11 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
       joined_rules = node.resolved_rules.members.map do |seq|
         rule_part = seq.to_a.join
-        rule_part.gsub!(/\s*([^,])\s*\n\s*/m, '\1 ') if node.style == :compressed
+        if node.style == :compressed
+          rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
+          rule_part.gsub!(/\s*([,+>])\s*/m, '\1')
+          rule_part.strip!
+        end
         rule_part
       end.join(rule_separator)
 
@@ -144,7 +152,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       old_spaces = '  ' * @tabs
       spaces = '  ' * (@tabs + 1)
       if node.style != :compressed
-        if node.options[:debug_info]
+        if node.options[:debug_info] && !@in_directive
           to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
         elsif node.options[:trace_selectors]
           to_return << "#{old_spaces}/* "
@@ -190,7 +198,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   def debug_info_rule(debug_info, options)
     node = Sass::Tree::DirectiveNode.new("@media -sass-debug-info")
-    debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
+    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).each do |k, v|
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(

data/lib/sass/util.rb

@@ -2,7 +2,6 @@ require 'erb'
 require 'set'
 require 'enumerator'
 require 'stringio'
-require 'strscan'
 require 'rbconfig'
 
 require 'sass/root'
@@ -219,6 +218,20 @@ module Sass
       lcs_backtrace(lcs_table(x, y, &block), x, y, x.size-1, y.size-1, &block)
     end
 
+    # Converts a Hash to an Array. This is usually identical to `Hash#to_a`,
+    # with the following exceptions:
+    #
+    # * In Ruby 1.8, `Hash#to_a` is not deterministically ordered, but this is.
+    # * In Ruby 1.9 when running tests, this is ordered in the same way it would
+    #   be under Ruby 1.8 (sorted key order rather than insertion order).
+    #
+    # @param hash [Hash]
+    # @return [Array]
+    def hash_to_a(hash)
+      return has.to_a unless ruby1_8? || defined?(Test::Unit)
+      return hash.sort_by {|k, v| k}
+    end
+
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -562,6 +575,24 @@ MSG
       ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
     end
 
+    # Destructively removes all elements from an array that match a block, and
+    # returns the removed elements.
+    #
+    # @param array [Array] The array from which to remove elements.
+    # @yield [el] Called for each element.
+    # @yieldparam el [*] The element to test.
+    # @yieldreturn [Boolean] Whether or not to extract the element.
+    # @return [Array] The extracted elements.
+    def extract!(array)
+      out = []
+      array.reject! do |e|
+        next false unless yield e
+        out << e
+        true
+      end
+      out
+    end
+
     # Returns the ASCII code of the given character.
     #
     # @param c [String] All characters but the first are ignored.
@@ -719,3 +750,5 @@ MSG
     end
   end
 end
+
+require 'sass/util/multibyte_string_scanner'

data/lib/sass/util/multibyte_string_scanner.rb

@@ -0,0 +1,134 @@
+require 'strscan'
+
+if Sass::Util.ruby1_8?
+  Sass::Util::MultibyteStringScanner = StringScanner
+else
+  # A wrapper of the native StringScanner class that works correctly with
+  # multibyte character encodings. The native class deals only in bytes, not
+  # characters, for methods like [#pos] and [#matched_size]. This class deals
+  # only in characters, instead.
+  class Sass::Util::MultibyteStringScanner < StringScanner
+    def self.new(str)
+      return StringScanner.new(str) if str.ascii_only?
+      super
+    end
+
+    def initialize(str)
+      super
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+    end
+
+    alias_method :byte_pos, :pos
+    alias_method :byte_matched_size, :matched_size
+
+    def check(pattern); _match super; end
+    def check_until(pattern); _matched super; end
+    def getch; _forward _match super; end
+    def match?(pattern); _size check(pattern); end
+    def matched_size; @mb_matched_size; end
+    def peek(len); string[@mb_pos, len]; end
+    alias_method :peep, :peek
+    def pos; @mb_pos; end
+    alias_method :pointer, :pos
+    def rest_size; rest.size; end
+    def scan(pattern); _forward _match super; end
+    def scan_until(pattern); _forward _matched super; end
+    def skip(pattern); _size scan(pattern); end
+    def skip_until(pattern); _matched _size scan_until(pattern); end
+
+    def get_byte
+      raise "MultibyteStringScanner doesn't support #get_byte."
+    end
+
+    def getbyte
+      raise "MultibyteStringScanner doesn't support #getbyte."
+    end
+
+    def pos=(n)
+      @mb_last_pos = nil
+
+      # We set position kind of a lot during parsing, so we want it to be as
+      # efficient as possible. This is complicated by the fact that UTF-8 is a
+      # variable-length encoding, so it's difficult to find the byte length that
+      # corresponds to a given character length.
+      #
+      # Our heuristic here is to try to count the fewest possible characters. So
+      # if the new position is close to the current one, just count the
+      # characters between the two; if the new position is closer to the
+      # beginning of the string, just count the characters from there.
+      if @mb_pos - n < @mb_pos / 2
+        # New position is close to old position
+        byte_delta = @mb_pos > n ? -string[n...@mb_pos].bytesize : string[@mb_pos...n].bytesize
+        super(byte_pos + byte_delta)
+      else
+        # New position is close to BOS
+        super(string[0...n].bytesize)
+      end
+      @mb_pos = n
+    end
+
+    def reset
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+
+    def scan_full(pattern, advance_pointer_p, return_string_p)
+      res = _match super(pattern, advance_pointer_p, true)
+      _forward res if advance_pointer_p
+      return res if return_string_p
+    end
+
+    def search_full(pattern, advance_pointer_p, return_string_p)
+      res = super(pattern, advance_pointer_p, true)
+      _forward res if advance_pointer_p
+      _matched((res if return_string_p))
+    end
+
+    def string=(str)
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+
+    def terminate
+      @mb_pos = string.size
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+    alias_method :clear, :terminate
+
+    def unscan
+      super
+      @mb_pos = @mb_last_pos
+      @mb_last_pos = @mb_matched_size = nil
+    end
+
+    private
+
+    def _size(str)
+      str && str.size
+    end
+
+    def _match(str)
+      @mb_matched_size = str && str.size
+      str
+    end
+
+    def _matched(res)
+      _match matched
+      res
+    end
+
+    def _forward(str)
+      @mb_last_pos = @mb_pos
+      @mb_pos += str.size if str
+      str
+    end
+  end
+end

data/test/sass/engine_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-require 'test_helper'
-require 'sass/test_helper'
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 require 'sass/engine'
 require 'stringio'
 require 'mock_importer'
@@ -608,13 +608,21 @@ CSS
   end
 
   def test_http_import
-    assert_equal("@import url(http://fonts.googleapis.com/css?family=Droid+Sans);\n",
+    assert_equal("@import \"http://fonts.googleapis.com/css?family=Droid+Sans\";\n",
       render("@import \"http://fonts.googleapis.com/css?family=Droid+Sans\""))
   end
 
-  def test_http_import_with_interpolation
-    assert_equal("@import url(http://fonts.googleapis.com/css?family=Droid+Sans);\n",
-      render("$family: unquote(\"Droid+Sans\")\n@import \"http://fonts.googleapis.com/css?family=\#{$family}\"\n"))
+  def test_import_with_interpolation
+    assert_warning(<<WARNING) do
+DEPRECATION WARNING on line 2 of test_import_with_interpolation_inline.sass:
+@import directives using \#{} interpolation will need to use url() in Sass 3.2.
+For example:
+
+  @import url("http://\#{$url}/style.css");
+WARNING
+      assert_equal("@import \"http://fonts.googleapis.com/css?family=Droid+Sans\";\n",
+        render("$family: unquote(\"Droid+Sans\")\n@import \"http://fonts.googleapis.com/css?family=\#{$family}\"\n"))
+    end
     assert_equal("@import url(\"http://fonts.googleapis.com/css?family=Droid+Sans\");\n",
       render("$family: unquote(\"Droid+Sans\")\n@import url(\"http://fonts.googleapis.com/css?family=\#{$family}\")\n"))
   end
@@ -1006,6 +1014,23 @@ foo
 SASS
   end
 
+  def test_debug_info_in_keyframes
+    assert_equal(<<CSS, render(<<SASS, :debug_info => true))
+@-webkit-keyframes warm {
+  from {
+    color: black; }
+
+  to {
+    color: red; } }
+CSS
+@-webkit-keyframes warm
+  from
+    color: black
+  to
+    color: red
+SASS
+  end
+
   def test_empty_first_line
     assert_equal("#a {\n  b: c; }\n", render("#a\n\n  b: c"))
   end
@@ -2448,6 +2473,15 @@ CSS
 SASS
   end
 
+  def test_selector_compression
+    assert_equal <<CSS, render(<<SASS, :style => :compressed)
+a>b,c+d,:-moz-any(e,f,g){h:i}
+CSS
+a > b, c + d, :-moz-any(e, f, g)
+  h: i
+SASS
+  end
+
   # Encodings
 
   unless Sass::Util.ruby1_8?
@@ -2560,6 +2594,31 @@ CSS
   a: b
 SASS
     end
+
+    # Encoding Regression Test
+
+    def test_multibyte_prop_name
+      assert_equal(<<CSS, render(<<SASS))
+@charset "UTF-8";
+#bar {
+  cölor: blue; }
+CSS
+#bar
+  cölor: blue
+SASS
+    end
+
+    def test_multibyte_and_interpolation
+      assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
+#bar {
+  background: a 0%; }
+CSS
+#bar {
+  // 
+  background: \#{a} 0%;
+}
+SCSS
+    end
   end
 
   def test_original_filename_set

data/test/sass/extend_test.rb

@@ -741,6 +741,22 @@ SCSS
 CSS
 :foo.baz {a: b}
 :bar {@extend .baz}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.baz:foo, :foo:after {
+  a: b; }
+CSS
+.baz:foo {a: b}
+:after {@extend .baz}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.baz:after, :foo:after {
+  a: b; }
+CSS
+.baz:after {a: b}
+:foo {@extend .baz}
 SCSS
 
     assert_equal <<CSS, render(<<SCSS)
@@ -1339,6 +1355,78 @@ CSS
 SCSS
   end
 
+  # Regression Tests
+
+  def test_duplicated_selector_with_newlines
+    assert_equal(<<CSS, render(<<SCSS))
+.example-1-1,
+.example-1-2,
+.my-page-1 .my-module-1-1,
+.example-1-3 {
+  a: b; }
+CSS
+.example-1-1,
+.example-1-2,
+.example-1-3 {
+  a: b;
+}
+
+.my-page-1 .my-module-1-1 {@extend .example-1-2}
+SCSS
+  end
+
+  def test_nested_selector_with_child_selector_hack_extendee
+    assert_equal <<CSS, render(<<SCSS)
+> .foo, > foo bar {
+  a: b; }
+CSS
+> .foo {a: b}
+foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_selector_with_child_selector_hack_extender
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, > .foo foo bar, > foo .foo bar {
+  a: b; }
+CSS
+.foo .bar {a: b}
+> foo bar {@extend .bar}
+SCSS
+  end
+
+  def test_nested_selector_with_child_selector_hack_extender_and_extendee
+    assert_equal <<CSS, render(<<SCSS)
+> .foo, > foo bar {
+  a: b; }
+CSS
+> .foo {a: b}
+> foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_selector_with_child_selector_hack_extender_and_sibling_selector_extendee
+    assert_equal <<CSS, render(<<SCSS)
+~ .foo {
+  a: b; }
+CSS
+~ .foo {a: b}
+> foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_selector_with_child_selector_hack_extender_and_extendee_and_newline
+    assert_equal <<CSS, render(<<SCSS)
+> .foo, > flip,
+> foo bar {
+  a: b; }
+CSS
+> .foo {a: b}
+flip,
+> foo bar {@extend .foo}
+SCSS
+  end
+
   private
 
   def render(sass, options = {})

data/test/sass/more_results/more_import.css

@@ -1,3 +1,5 @@
+@import url(basic.css);
+@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -22,8 +24,6 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
-@import url(basic.css);
-@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/results/import.css

@@ -1,3 +1,5 @@
+@import url(basic.css);
+@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -24,8 +26,6 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
-@import url(basic.css);
-@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/results/import_charset.css

@@ -1,4 +1,5 @@
 @charset "UTF-8";
+@import url(foo.css);
 .foo { a: b; }
 
 .bar { a: щ; }

data/test/sass/results/import_charset_1_8.css

@@ -1,4 +1,5 @@
 @charset "IBM866";
+@import url(foo.css);
 .foo { a: b; }
 
 .bar { a: �; }

data/test/sass/results/import_charset_ibm866.css

@@ -1,4 +1,5 @@
 @charset "IBM866";
+@import url(foo.css);
 .foo { a: b; }
 
 .bar { a: �; }

data/test/sass/results/scss_import.css

@@ -1,3 +1,5 @@
+@import url(basic.css);
+@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -24,8 +26,6 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
-@import url(basic.css);
-@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/script_test.rb

@@ -432,6 +432,11 @@ SASS
     assert_raise_message(Sass::SyntaxError, "wrong number of arguments (1 for 0) for `arg-error'") {resolve("arg-error(1)")}
   end
 
+  def test_boolean_ops_short_circuit
+    assert_equal "false", resolve("$ie and $ie <= 7", {}, env('ie' => Sass::Script::Bool.new(false)))
+    assert_equal "true", resolve("$ie or $undef", {}, env('ie' => Sass::Script::Bool.new(true)))
+  end
+
   # Regression Tests
 
   def test_funcall_has_higher_precedence_than_color_name

data/test/sass/scss/scss_test.rb

@@ -1224,11 +1224,11 @@ SCSS
 
 
   def test_newlines_removed_from_selectors_when_compressed
-    assert_equal <<CSS, render(<<SCSS, :style=>:compressed)
+    assert_equal <<CSS, render(<<SCSS, :style => :compressed)
 z a,z b{display:block}
 CSS
-a,
-b {
+a
+, b {
   z & {
     display: block;
   }

data/test/sass/templates/import_charset.sass

@@ -1,6 +1,8 @@
 .foo
   a: b
 
+@import "foo.css"
+
 // Even though the imported file is in IBM866,
 // since the root file is in UTF-8/ASCII
 // the output will end up being UTF-8.

data/test/sass/templates/import_charset_1_8.sass

@@ -1,4 +1,6 @@
 .foo
   a: b
 
+@import "foo.css"
+
 @import "imported_charset_ibm866"

data/test/sass/templates/import_charset_ibm866.sass

@@ -3,6 +3,8 @@
 .foo
   a: b
 
+@import "foo.css"
+
 // Even though the imported file is in UTF-8,
 // since the root file is in IBM866
 // the output will end up being IBM866.

data/test/sass/util/multibyte_string_scanner_test.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/../../test_helper'
+
+unless Sass::Util.ruby1_8?
+  class MultibyteStringScannerTest < Test::Unit::TestCase
+    def setup
+      @scanner = Sass::Util::MultibyteStringScanner.new("cölorfül")
+    end
+
+    def test_initial
+      assert_scanner_state 0, 0, nil, nil
+    end
+
+    def test_check
+      assert_equal 'cö', @scanner.check(/../)
+      assert_scanner_state 0, 0, 2, 3
+      assert_equal 0, @scanner.pos
+      assert_equal 0, @scanner.pos
+      assert_equal 2, @scanner.matched_size
+      assert_equal 3, @scanner.byte_matched_size
+    end
+
+    def test_check_until
+      assert_equal 'cölorfü', @scanner.check_until(/f./)
+      assert_scanner_state 0, 0, 2, 3
+    end
+
+    def test_getch
+      assert_equal 'c', @scanner.getch
+      assert_equal 'ö', @scanner.getch
+      assert_scanner_state 2, 3, 1, 2
+    end
+
+    def test_match?
+      assert_equal 2, @scanner.match?(/../)
+      assert_scanner_state 0, 0, 2, 3
+    end
+
+    def test_peek
+      assert_equal 'cö', @scanner.peek(2)
+      assert_scanner_state 0, 0, nil, nil
+    end
+
+    def test_rest_size
+      assert_equal 'cö', @scanner.scan(/../)
+      assert_equal 6, @scanner.rest_size
+    end
+
+    def test_scan
+      assert_equal 'cö', @scanner.scan(/../)
+      assert_scanner_state 2, 3, 2, 3
+    end
+
+    def test_scan_until
+      assert_equal 'cölorfü', @scanner.scan_until(/f./)
+      assert_scanner_state 7, 9, 2, 3
+    end
+
+    def test_skip
+      assert_equal 2, @scanner.skip(/../)
+      assert_scanner_state 2, 3, 2, 3
+    end
+
+    def test_skip_until
+      assert_equal 7, @scanner.skip_until(/f./)
+      assert_scanner_state 7, 9, 2, 3
+    end
+
+    def test_set_pos
+      @scanner.pos = 7
+      assert_scanner_state 7, 9, nil, nil
+      @scanner.pos = 6
+      assert_scanner_state 6, 7, nil, nil
+      @scanner.pos = 1
+      assert_scanner_state 1, 1, nil, nil
+    end
+
+    def test_reset
+      @scanner.scan(/../)
+      @scanner.reset
+      assert_scanner_state 0, 0, nil, nil
+    end
+
+    def test_scan_full
+      assert_equal 'cö', @scanner.scan_full(/../, true, true)
+      assert_scanner_state 2, 3, 2, 3
+
+      @scanner.reset
+      assert_equal 'cö', @scanner.scan_full(/../, false, true)
+      assert_scanner_state 0, 0, 2, 3
+
+      @scanner.reset
+      assert_nil @scanner.scan_full(/../, true, false)
+      assert_scanner_state 2, 3, 2, 3
+
+      @scanner.reset
+      assert_nil @scanner.scan_full(/../, false, false)
+      assert_scanner_state 0, 0, 2, 3
+    end
+
+    def test_search_full
+      assert_equal 'cölorfü', @scanner.search_full(/f./, true, true)
+      assert_scanner_state 7, 9, 2, 3
+
+      @scanner.reset
+      assert_equal 'cölorfü', @scanner.search_full(/f./, false, true)
+      assert_scanner_state 0, 0, 2, 3
+
+      @scanner.reset
+      assert_nil @scanner.search_full(/f./, true, false)
+      assert_scanner_state 7, 9, 2, 3
+
+      @scanner.reset
+      assert_nil @scanner.search_full(/f./, false, false)
+      assert_scanner_state 0, 0, 2, 3
+    end
+
+    def test_set_string
+      @scanner.scan(/../)
+      @scanner.string = 'föóbâr'
+      assert_scanner_state 0, 0, nil, nil
+    end
+
+    def test_terminate
+      @scanner.scan(/../)
+      @scanner.terminate
+      assert_scanner_state 8, 10, nil, nil
+    end
+
+    def test_unscan
+      @scanner.scan(/../)
+      @scanner.scan_until(/f./)
+      @scanner.unscan
+      assert_scanner_state 2, 3, nil, nil
+    end
+
+    private
+
+    def assert_scanner_state(pos, byte_pos, matched_size, byte_matched_size)
+      assert_equal pos, @scanner.pos, 'pos'
+      assert_equal byte_pos, @scanner.byte_pos, 'byte_pos'
+      assert_equal matched_size, @scanner.matched_size, 'matched_size'
+      assert_equal byte_matched_size, @scanner.byte_matched_size, 'byte_matched_size'
+    end
+  end
+end

data/test/sass/util_test.rb

@@ -159,6 +159,12 @@ class UtilTest < Test::Unit::TestCase
       enum_cons(%w[foo bar baz], 2).map {|s1, s2| "#{s1}#{s2}"})
   end
 
+  def test_extract
+    arr = [1, 2, 3, 4, 5]
+    assert_equal([1, 3, 5], extract!(arr) {|e| e % 2 == 1})
+    assert_equal([2, 4], arr)
+  end
+
   def test_ord
     assert_equal(102, ord("f"))
     assert_equal(98, ord("bar"))

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 3
   - 1
-  - 12
-  version: 3.1.12
+  - 13
+  version: 3.1.13
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-16 00:00:00 -08:00
+date: 2012-02-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -116,6 +116,7 @@ files:
 - lib/sass/root.rb
 - lib/sass/importers.rb
 - lib/sass/logger.rb
+- lib/sass/util/multibyte_string_scanner.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/scss.rb
 - lib/sass/scss/static_parser.rb
@@ -257,6 +258,7 @@ files:
 - test/sass/conversion_test.rb
 - test/sass/script_test.rb
 - test/sass/util/subset_map_test.rb
+- test/sass/util/multibyte_string_scanner_test.rb
 - test/sass/callbacks_test.rb
 - test/sass/importer_test.rb
 - test/sass/scss/css_test.rb
@@ -356,6 +358,7 @@ test_files:
 - test/sass/conversion_test.rb
 - test/sass/script_test.rb
 - test/sass/util/subset_map_test.rb
+- test/sass/util/multibyte_string_scanner_test.rb
 - test/sass/callbacks_test.rb
 - test/sass/importer_test.rb
 - test/sass/scss/css_test.rb