sass 3.3.0.alpha.93 → 3.3.0.alpha.101

data/REVISION

@@ -1 +1 @@
-655e8ae0d3bcab12d522eac27a7f7cb876475756
+d412ca4d9bd9fca447d84e1fd960268a8419b9f3

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.93
+3.3.0.alpha.101

data/VERSION_DATE

@@ -1 +1 @@
-23 February 2013 01:38:58 GMT
+27 February 2013 19:13:18 GMT

data/bin/sass

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 # The command line Sass parser.
 
-require File.dirname(__FILE__) + '/../lib/sass'
+THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+require File.dirname(THIS_FILE) + '/../lib/sass'
 require 'sass/exec'
 
 opts = Sass::Exec::Sass.new(ARGV)

data/bin/sass-convert

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/sass'
+THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+require File.dirname(THIS_FILE) + '/../lib/sass'
 require 'sass/exec'
 
 opts = Sass::Exec::SassConvert.new(ARGV)

data/bin/scss

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 # The command line Sass parser.
 
-require File.dirname(__FILE__) + '/../lib/sass'
+THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+require File.dirname(THIS_FILE) + '/../lib/sass'
 require 'sass/exec'
 
 opts = Sass::Exec::Scss.new(ARGV)

data/lib/sass/cache_stores/chain.rb

@@ -23,7 +23,7 @@ module Sass
       def retrieve(key, sha)
         @caches.each_with_index do |c, i|
           next unless obj = c.retrieve(key, sha)
-          @caches[0...i].each {|c| c.store(key, sha, obj)}
+          @caches[0...i].each {|prev| prev.store(key, sha, obj)}
           return obj
         end
         nil

data/lib/sass/cache_stores/filesystem.rb

@@ -17,7 +17,6 @@ module Sass
       # @see Base#\_retrieve
       def _retrieve(key, version, sha)
         return unless File.readable?(path_to(key))
-        contents = nil
         File.open(path_to(key), "rb") do |f|
           if f.readline("\n").strip == version && f.readline("\n").strip == sha
             return f.read

data/lib/sass/engine.rb

@@ -314,7 +314,7 @@ module Sass
     # @return [[Sass::Engine]] The dependency documents.
     def dependencies
       _dependencies(Set.new, engines = Set.new)
-      engines - [self]
+      Sass::Util.array_minus(engines, [self])
     end
 
     # Helper for \{#dependencies}.
@@ -817,6 +817,12 @@ WARNING
           @line, to_parser_offset(@offset))
         Tree::MediaNode.new(parser.parse_media_query_list.to_a)
       else
+        unprefixed_directive = directive.gsub(/^-[a-z0-9]+-/i, '')
+        if unprefixed_directive == 'supports'
+          parser = Sass::SCSS::Parser.new(value, @options[:filename], @line)
+          return Tree::SupportsNode.new(directive, parser.parse_supports_condition)
+        end
+
         Tree::DirectiveNode.new(
           value.nil? ? ["@#{directive}"] : ["@#{directive} "] + parse_interp(value, offset))
       end

data/lib/sass/exec.rb

@@ -317,6 +317,7 @@ END
         return watch_or_update if @options[:watch] || @options[:update]
         super
         @options[:for_engine][:filename] = @options[:filename]
+        @options[:for_engine][:css_filename] = @options[:output].path if @options[:output].is_a?(File)
 
         begin
           input = @options[:input]

data/lib/sass/importers/filesystem.rb

@@ -30,7 +30,7 @@ module Sass
 
       # @see Base#mtime
       def mtime(name, options)
-        file, s = Sass::Util.destructure(find_real_file(@root, name, options))
+        file, _ = Sass::Util.destructure(find_real_file(@root, name, options))
         File.mtime(file) if file
       rescue Errno::ENOENT
         nil

data/lib/sass/media.rb

@@ -140,10 +140,7 @@ module Sass::Media
         type = t1
         mod = m1.empty? ? m2 : m1
       end
-      q = Query.new([], [], other.expressions + expressions)
-      q.type = [type]
-      q.modifier = [mod]
-      return q
+      return Query.new([mod], [type], other.expressions + expressions)
     end
 
     # Returns the CSS for the media query.

data/lib/sass/plugin/compiler.rb

@@ -171,7 +171,7 @@ module Sass::Plugin
           # Get the relative path to the file
           name = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
           css = css_filename(name, css_location)
-          sourcemap = Util::sourcemap_name(css) if engine_options[:sourcemap]
+          sourcemap = Sass::Util.sourcemap_name(css) if engine_options[:sourcemap]
           individual_files << [file, css, sourcemap]
         end
       end

data/lib/sass/script/funcall.rb

@@ -107,18 +107,53 @@ module Sass
           opts(Functions::EvaluationContext.new(local_environment).send(ruby_name, *args))
         end
       rescue ArgumentError => e
+        message = e.message
+
         # If this is a legitimate Ruby-raised argument error, re-raise it.
         # Otherwise, it's an error in the user's stylesheet, so wrap it.
-        if e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/ &&
-            # JRuby (as of 1.6.7.2) doesn't put the actual method for
-            # which the argument error was thrown in the backtrace, so
-            # we detect whether our send threw an argument error.
-            (RUBY_PLATFORM !~ /java/ || e.backtrace[0] !~ /:in `send'$/ ||
-             e.backtrace[1] !~ /:in `_perform'$/)
+        if Sass::Util.rbx?
+          # Rubinius has a different error report string than vanilla Ruby. It
+          # also doesn't put the actual method for which the argument error was
+          # thrown in the backtrace, nor does it include `send`, so we look for
+          # `_perform`.
+          if e.message =~ /^method '([^']+)': given (\d+), expected (\d+)/
+            error_name, given, expected = $1, $2, $3
+            raise e if error_name != ruby_name || e.backtrace[0] !~ /:in `_perform'$/
+            message = "wrong number of arguments (#{given} for #{expected})"
+          end
+        elsif Sass::Util.jruby?
+          if Sass::Util.jruby1_6?
+            should_maybe_raise = e.message =~ /^wrong number of arguments \((\d+) for (\d+)\)/ &&
+              # The one case where JRuby does include the Ruby name of the function
+              # is manually-thrown ArgumentErrors, which are indistinguishable from
+              # legitimate ArgumentErrors. We treat both of these as
+              # Sass::SyntaxErrors even though it can hide Ruby errors.
+              e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
+          else
+            should_maybe_raise = e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
+            given, expected = $1, $2
+          end
+
+          if should_maybe_raise
+            # JRuby 1.7 includes __send__ before send and _perform.
+            trace = e.backtrace.dup
+            raise e if !Sass::Util.jruby1_6? && trace.shift !~ /:in `__send__'$/
+
+            # JRuby (as of 1.7.2) doesn't put the actual method
+            # for which the argument error was thrown in the backtrace, so we
+            # detect whether our send threw an argument error.
+            if !(trace[0] =~ /:in `send'$/ && trace[1] =~ /:in `_perform'$/)
+              raise e
+            elsif !Sass::Util.jruby1_6?
+              # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
+              message = "wrong number of arguments (#{given} for #{expected})"
+            end
+          end
+        elsif e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
+            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
           raise e
         end
-        raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
+        raise Sass::SyntaxError.new("#{message} for `#{name}'")
       end
 
       # This method is factored out from `_perform` so that compass can override

data/lib/sass/script/functions.rb

@@ -379,18 +379,11 @@ module Sass::Script
       def assert_unit(number, unit, name = nil)
         assert_type number, :Number, name
         return if number.is_unit?(unit)
-        if unit
-          if name
-            raise ArgumentError.new("Expected $#{name} to have a unit of #{unit} but got #{number}")
-          else
-            raise ArgumentError.new("Expected #{number} to have a unit of #{unit}")
-          end
+        expectation = unit ? "have a unit of #{unit}" : "be unitless"
+        if name
+          raise ArgumentError.new("Expected $#{name} to #{expectation} but got #{number}")
         else
-          if name
-            raise ArgumentError.new("Expected $#{name} to be unitless but got #{number}")
-          else
-            raise ArgumentError.new("Expected #{number} to be unitless")
-          end
+          raise ArgumentError.new("Expected #{number} to #{expectation}")
         end
       end
 
@@ -1575,9 +1568,9 @@ module Sass::Script
       length = nil
       values = []
       lists.each do |list|
-        assert_type list, :List
-        values << list.value.dup
-        length = length.nil? ? list.value.length : [length, list.value.length].min
+        array = list.to_a
+        values << array.dup
+        length = length.nil? ? array.length : [length, array.length].min
       end
       values.each do |value|
         value.slice!(length)
@@ -1595,8 +1588,7 @@ module Sass::Script
     #   index(1px solid red, solid) => 2
     #   index(1px solid red, dashed) => false
     def index(list, value)
-      assert_type list, :List
-      index = list.value.index {|e| e.eq(value).to_bool }
+      index = list.to_a.index {|e| e.eq(value).to_bool }
       if index
         Number.new(index + 1)
       else

data/lib/sass/script/lexer.rb

@@ -248,8 +248,6 @@ module Sass
       end
 
       def _variable(rx)
-        line = @line
-        offset = @offset
         return unless scan(rx)
 
         [:const, @scanner[2]]

data/lib/sass/script/parser.rb

@@ -372,8 +372,6 @@ RUBY
         splat = nil
         must_have_default = false
         loop do
-          line = @lexer.line
-          offset = @lexer.offset
           c = assert_tok(:const)
           var = Script::Variable.new(c.value)
           var.source_range = range(c.offset)
@@ -394,38 +392,41 @@ RUBY
       end
 
       def fn_arglist
-        arglist(:fn_arglist, :equals)
+        arglist(:equals, "function argument")
       end
 
       def mixin_arglist
-        arglist(:mixin_arglist, :interpolation)
+        arglist(:interpolation, "mixin argument")
       end
 
-      def arglist(type, subexpr)
+      def arglist(subexpr, description)
         return unless e = send(subexpr)
-        if @lexer.peek && @lexer.peek.type == :colon
-          name = e
-          @lexer.expected!("comma") unless name.is_a?(Variable)
-          assert_tok(:colon)
-          keywords = {name.underscored_name => assert_expr(subexpr, EXPR_NAMES[type])}
-        end
 
-        unless try_tok(:comma)
-          return [], keywords if keywords
-          return [], {}, e if try_tok(:splat)
-          return [e], {}
-        end
+        args = []
+        keywords = {}
+        loop do
+          if @lexer.peek && @lexer.peek.type == :colon
+            name = e
+            @lexer.expected!("comma") unless name.is_a?(Variable)
+            assert_tok(:colon)
+            value = assert_expr(subexpr, description)
+
+            if keywords[name.underscored_name]
+              raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
+            end
 
-        other_args, other_keywords, splat = assert_expr(type)
-        if keywords
-          if !other_args.empty? || splat
-            raise SyntaxError.new("Positional arguments must come before keyword arguments.")
-          elsif other_keywords[name.underscored_name]
-            raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
+            keywords[name.underscored_name] = value
+          else
+            if !keywords.empty?
+              raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+            end
+
+            return args, keywords, e if try_tok(:splat)
+            args << e
           end
-          return other_args, keywords.merge(other_keywords), splat
-        else
-          return [e, *other_args], other_keywords, splat
+
+          return args, keywords unless try_tok(:comma)
+          e = assert_expr(subexpr, description)
         end
       end
 

data/lib/sass/scss/parser.rb

@@ -64,6 +64,18 @@ module Sass
         ql
       end
 
+      # Parses a supports query condition.
+      #
+      # @return [Sass::Supports::Condition] The parsed condition
+      # @raise [Sass::SyntaxError] if there's a syntax error in the condition,
+      #   or if it doesn't take up the entire input string.
+      def parse_supports_condition
+        init_scanner!
+        condition = supports_condition
+        expected("supports condition") unless @scanner.eos?
+        condition
+      end
+
       private
 
       include Sass::SCSS::RX
@@ -1021,7 +1033,7 @@ MESSAGE
         offset = @offset
         @strs.push ""
         throw_error {yield} && @strs.last
-      rescue Sass::SyntaxError => e
+      rescue Sass::SyntaxError
         @scanner.pos = pos
         @line = line
         @offset = offset

data/lib/sass/selector/simple_sequence.rb

@@ -107,7 +107,7 @@ module Sass
           # If A {@extend B} and C {...},
           # seq is A, sels is B, and self is C
 
-          self_without_sel = self.members - sels
+          self_without_sel = Sass::Util.array_minus(self.members, sels)
           group.each {|e, _| e.result = :failed_to_unify unless e.result == :succeeded}
           next unless unified = seq.members.last.unify(self_without_sel, subject?)
           group.each {|e, _| e.result = :succeeded}

data/lib/sass/tree/comment_node.rb

@@ -70,13 +70,13 @@ module Sass::Tree
     private
 
     def normalize_indentation(str)
-      pre = str.split("\n").inject(str[/^[ \t]*/].split("")) do |pre, line|
+      ind = 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}/, '')
+      str.gsub(/^#{ind}/, '')
     end
   end
 end

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

@@ -32,6 +32,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     end
   end
 
+  MERGEABLE_DIRECTIVES = [Sass::Tree::MediaNode]
+
   # Runs a block of code with the current parent node
   # replaced with the given node.
   #
@@ -39,11 +41,18 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # @yield A block in which the parent is set to `parent`.
   # @return [Object] The return value of the block.
   def with_parent(parent)
-    @parent_directives.push parent if parent.is_a?(Sass::Tree::DirectiveNode)
+    if parent.is_a?(Sass::Tree::DirectiveNode)
+      if MERGEABLE_DIRECTIVES.any? {|klass| parent.is_a?(klass)}
+        old_parent_directive = @parent_directives.pop
+      end
+      @parent_directives.push parent
+    end
+
     old_parent, @parent = @parent, parent
     yield
   ensure
     @parent_directives.pop if parent.is_a?(Sass::Tree::DirectiveNode)
+    @parent_directives.push old_parent_directive if old_parent_directive
     @parent = old_parent
   end
 

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

@@ -14,11 +14,13 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
     begin
       unless keywords.empty?
-        unknown_args = keywords.keys - callable.args.map {|var| var.first.underscored_name}
+        unknown_args = Sass::Util.array_minus(keywords.keys,
+          callable.args.map {|var| var.first.underscored_name})
         if callable.splat && unknown_args.include?(callable.splat.underscored_name)
           raise Sass::SyntaxError.new("Argument $#{callable.splat.name} of #{downcase_desc} cannot be used as a named argument.")
         elsif unknown_args.any?
-          raise Sass::SyntaxError.new("#{desc} doesn't have #{unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'} #{unknown_args.map{|name| "$#{name}"}.join ', '}.")
+          description = unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'
+          raise Sass::SyntaxError.new("#{desc} doesn't have #{description} #{unknown_args.map {|name| "$#{name}"}.join ', '}.")
         end
       end
     rescue Sass::SyntaxError => keyword_exception

data/lib/sass/util.rb

@@ -256,6 +256,33 @@ module Sass
       arr
     end
 
+    # Returns a sub-array of `minuend` containing only elements that are also in
+    # `subtrahend`. Ensures that the return value has the same order as
+    # `minuend`, even on Rubinius where that's not guaranteed by {Array#-}.
+    #
+    # @param minuend [Array]
+    # @param subtrahend [Array]
+    # @return [Array]
+    def array_minus(minuend, subtrahend)
+      return minuend - subtrahend unless rbx?
+      set = Set.new(minuend) - subtrahend
+      minuend.select {|e| set.include?(e)}
+    end
+
+    # Returns a string description of the character that caused an
+    # `Encoding::UndefinedConversionError`.
+    #
+    # @param [Encoding::UndefinedConversionError]
+    # @return [String]
+    def undefined_conversion_error_char(e)
+      # Rubinius (as of 2.0.0.rc1) pre-quotes the error character.
+      return e.error_char if rbx?
+      # JRuby (as of 1.7.2) doesn't have an error_char field on
+      # Encoding::UndefinedConversionError.
+      return e.error_char.dump unless jruby?
+      e.message[/^"[^"]+"/] #"
+    end
+
     # Asserts that `value` falls within `range` (inclusive), leaving
     # room for slight floating-point errors.
     #
@@ -462,6 +489,27 @@ module Sass
       RUBY_ENGINE == "ironruby"
     end
 
+    # Whether or not this is running on Rubinius.
+    #
+    # @return [Boolean]
+    def rbx?
+      RUBY_ENGINE == "rbx"
+    end
+
+    # Whether or not this is running on JRuby.
+    #
+    # @return [Boolean]
+    def jruby?
+      RUBY_PLATFORM =~ /java/
+    end
+
+    # Returns an array of ints representing the JRuby version number.
+    #
+    # @return [Array<Fixnum>]
+    def jruby_version
+      $jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
+    end
+
     # Like `Dir.glob`, but works with backslash-separated paths on Windows.
     #
     # @param path [String]
@@ -512,6 +560,11 @@ module Sass
       ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
     end
 
+    # Wehter or not this is running under JRuby 1.6 or lower.
+    def jruby1_6?
+      jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
+    end
+
     # Whether or not this is running under MacRuby.
     #
     # @return [Boolean]
@@ -548,7 +601,7 @@ module Sass
           line.encode(encoding)
         rescue Encoding::UndefinedConversionError => e
           yield <<MSG.rstrip, i + 1
-Invalid #{encoding.name} character #{e.error_char.dump}
+Invalid #{encoding.name} character #{undefined_conversion_error_char(e)}
 MSG
         end
       end