sass 3.3.0.rc.1 → 3.3.0.rc.2

data/Rakefile

@@ -21,7 +21,7 @@ end
 
 # ----- Code Style Enforcement -----
 
-if RUBY_VERSION !~ /^(1\.8|2\.1)/ && (ENV.has_key?("RUBOCOP") && ENV["RUBOCOP"] == "true" || !ENV.has_key?("RUBOCOP"))
+if RUBY_VERSION !~ /^(1\.8|2\.1)/ && (ENV.has_key?("RUBOCOP") && ENV["RUBOCOP"] == "true" || !(ENV.has_key?("RUBOCOP") || ENV.has_key?("TEST")))
   require 'rubocop/rake_task'
   Rubocop::RakeTask.new do |t|
     t.patterns = FileList["lib/**/*"]

data/VERSION

@@ -1 +1 @@
-3.3.0.rc.1
+3.3.0.rc.2

data/VERSION_DATE

@@ -1 +1 @@
-12 October 2013 15:48:52 GMT
+23 November 2013 02:13:52 UTC

data/lib/sass.rb

@@ -17,6 +17,11 @@ require 'sass/version'
 #
 # Also see the {file:SASS_REFERENCE.md full Sass reference}.
 module Sass
+  class << self
+    # @private
+    attr_accessor :tests_running
+  end
+
   # The global load paths for Sass files. This is meant for plugins and
   # libraries to register the paths to their Sass stylesheets to that they may
   # be `@imported`. This load path is used by every instance of {Sass::Engine}.

data/lib/sass/engine.rb

@@ -88,8 +88,6 @@ module Sass
   #     output = sass_engine.render
   #     puts output
   class Engine
-    include Sass::Util
-
     # A line of Sass code.
     #
     # `text`: `String`
@@ -375,7 +373,7 @@ ERR
     end
 
     def encode_and_set_charset(rendered)
-      return rendered if ruby1_8?
+      return rendered if Sass::Util.ruby1_8?
       begin
         # Try to convert the result to the original encoding,
         # but if that doesn't work fall back on UTF-8
@@ -431,7 +429,7 @@ ERR
     def check_encoding!
       return if @checked_encoding
       @checked_encoding = true
-      @template, @original_encoding = check_sass_encoding(@template) do |msg, line|
+      @template, @original_encoding = Sass::Util.check_sass_encoding(@template) do |msg, line|
         raise Sass::SyntaxError.new(msg, :line => line)
       end
     end
@@ -766,7 +764,7 @@ WARNING
           value = self.class.parse_interp(
             line.text, line.index, to_parser_offset(line.offset), :filename => @filename)
         end
-        value = with_extracted_values(value) do |str|
+        value = Sass::Util.with_extracted_values(value) do |str|
           str = str.gsub(/^#{line.comment_tab_str}/m, '')[2..-1] # get rid of // or /*
           format_comment_text(str, silent)
         end

data/lib/sass/plugin.rb

@@ -33,7 +33,6 @@ module Sass
   #     #=> Compiling app/sass/ie.scss to public/stylesheets/ie.css
   # @see Sass::Plugin::Compiler
   module Plugin
-    include Sass::Util
     extend self
 
     @checked_for_updates = false

data/lib/sass/plugin/compiler.rb

@@ -27,7 +27,6 @@ module Sass::Plugin
   # * `:never_update`
   # * `:always_check`
   class Compiler
-    include Sass::Util
     include Configuration
     extend Sass::Callbacks
 
@@ -61,7 +60,7 @@ module Sass::Plugin
     # when an exception CSS file is being written.
     # To run an action for those files, use \{#on\_compilation\_error}.
     #
-    # @yield [template, css]
+    # @yield [template, css, sourcemap]
     # @yieldparam template [String]
     #   The location of the Sass/SCSS file being updated.
     # @yieldparam css [String]

data/lib/sass/script/functions.rb

@@ -219,6 +219,9 @@ module Sass::Script
   # \{#mixin_exists mixin-exists($name)}
   # : Returns whether a mixin with the given name exists.
   #
+  # \{#inspect inspect($value)}
+  # : Returns the string representation of a value as it would be represented in Sass.
+  #
   # \{#type_of type-of($value)}
   # : Returns the type of a value.
   #
@@ -1155,12 +1158,12 @@ module Sass::Script
     #   same time
     def change_color(color, kwargs)
       assert_type color, :Color, :color
-      with = Sass::Util.map_hash(%w[red green blue hue saturation lightness alpha]) do |name, max|
+      with = Sass::Util.to_hash(%w[red green blue hue saturation lightness alpha].map do |name|
         val = kwargs.delete(name)
         next unless val
         assert_type val, :Number, name
         [name.to_sym, val.value]
-      end
+      end)
 
       unless kwargs.empty?
         name, val = kwargs.to_a.first
@@ -2154,6 +2157,17 @@ module Sass::Script
     end
     declare :mixin_exists, [:name]
 
+
+    # Return a string containing the value as its Sass representation.
+    #
+    # @param value [Sass::Script::Value::Base] The value to inspect.
+    # @return [Sass::Script::Value::String] A respresentation of the value as
+    #   it would be written in Sass.
+    def inspect(value)
+      unquoted_string(value.to_sass)
+    end
+    declare :inspect, [:value]
+
     private
 
     # This method implements the pattern of transforming a numeric value into

data/lib/sass/script/lexer.rb

@@ -117,18 +117,28 @@ module Sass
       # while the boolean represents whether or not the string
       # is following an interpolated segment.
       STRING_REGULAR_EXPRESSIONS = {
-        [:double, false] => string_re('"', '"'),
-        [:single, false] => string_re("'", "'"),
-        [:double, true] => string_re('', '"'),
-        [:single, true] => string_re('', "'"),
-        [:uri, false] => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
-        [:uri, true] => /(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        :double => {
+          false => string_re('"', '"'),
+          true => string_re('', '"')
+        },
+        :single => {
+          false => string_re("'", "'"),
+          true => string_re('', "'")
+        },
+        :uri => {
+          false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+        },
         # 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, false] => /url-prefix\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
-        [:url_prefix, true] => /(#{URLCHAR}*?)(#{W}\)|#\{)/,
-        [:domain, false] => /domain\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
-        [:domain, true] => /(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        :url_prefix => {
+          false => /url-prefix\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+        },
+        :domain => {
+          false => /domain\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+        }
       }
 
       # @param str [String, StringScanner] The source text to lex
@@ -265,7 +275,7 @@ module Sass
       end
 
       def string(re, open)
-        return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
+        return unless scan(STRING_REGULAR_EXPRESSIONS[re][open])
         if @scanner[2] == '#{' # '
           @scanner.pos -= 2 # Don't actually consume the #{
           @offset -= 2
@@ -364,7 +374,7 @@ MESSAGE
         return unless str
         c = str.count("\n")
         @line += c
-        @offset = (c == 0 ? @offset + str.size : str[/\n([^\n]*)/, 1].size + 1)
+        @offset = (c == 0 ? @offset + str.size : str.size - str.rindex("\n") + 1)
         str
       end
 

data/lib/sass/script/parser.rb

@@ -219,7 +219,7 @@ module Sass
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect})
               return interp if interp
               return unless e = #{sub}
-              while tok = try_tok(#{ops.map {|o| o.inspect}.join(', ')})
+              while tok = try_toks(#{ops.map {|o| o.inspect}.join(', ')})
                 if interp = try_op_before_interp(tok, e)
                   other_interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}, interp)
                   return interp unless other_interp
@@ -266,12 +266,12 @@ RUBY
         return unless e
         return list e, start_pos unless @lexer.peek && @lexer.peek.type == :colon
 
-        key, value = map_pair(e)
-        map = node(Sass::Script::Tree::MapLiteral.new([[key, value]]), start_pos)
+        pair = map_pair(e)
+        map = node(Sass::Script::Tree::MapLiteral.new([pair]), start_pos)
         while try_tok(:comma)
-          return map unless (pair = map_pair)
-          key, value = pair
-          map.pairs << [key, value]
+          pair = map_pair
+          return map unless pair
+          map.pairs << pair
         end
         map
       end
@@ -321,7 +321,7 @@ RUBY
 
       def try_ops_after_interp(ops, name, prev = nil)
         return unless @lexer.after_interpolation?
-        op = try_tok(*ops)
+        op = try_toks(*ops)
         return unless op
         interp = try_op_before_interp(op, prev)
         return interp if interp
@@ -413,12 +413,12 @@ RUBY
           if try_tok(:colon)
             val = assert_expr(:space)
             must_have_default = true
-          elsif must_have_default
-            raise SyntaxError.new(
-              "Required argument #{var.inspect} must come before any optional arguments.")
           elsif try_tok(:splat)
             splat = var
             break
+          elsif must_have_default
+            raise SyntaxError.new(
+              "Required argument #{var.inspect} must come before any optional arguments.")
           end
           res << [var, val]
           break unless try_tok(:comma)
@@ -543,7 +543,7 @@ RUBY
       end
 
       def literal
-        t = try_tok(:color, :bool, :null)
+        t = try_toks(:color, :bool, :null)
         return literal_node(t.value, t.source_range) if t
       end
 
@@ -564,13 +564,26 @@ RUBY
         @lexer.expected!(expected || EXPR_NAMES[name] || EXPR_NAMES[:default])
       end
 
-      def assert_tok(*names)
-        t = try_tok(*names)
+      def assert_tok(name)
+        # Avoids an array allocation caused by argument globbing in assert_toks.
+        t = try_tok(name)
+        return t if t
+        @lexer.expected!(Lexer::TOKEN_NAMES[name] || name.to_s)
+      end
+
+      def assert_toks(*names)
+        t = try_toks(*names)
         return t if t
         @lexer.expected!(names.map {|tok| Lexer::TOKEN_NAMES[tok] || tok}.join(" or "))
       end
 
-      def try_tok(*names)
+      def try_tok(name)
+        # Avoids an array allocation caused by argument globbing in the try_toks method.
+        peeked = @lexer.peek
+        peeked && name == peeked.type && @lexer.next
+      end
+
+      def try_toks(*names)
         peeked = @lexer.peek
         peeked && names.include?(peeked.type) && @lexer.next
       end

data/lib/sass/script/tree/variable.rb

@@ -47,7 +47,7 @@ module Sass::Script::Tree
     def _perform(environment)
       val = environment.var(name)
       raise Sass::SyntaxError.new("Undefined variable: \"$#{name}\".") unless val
-      if val.is_a?(Sass::Script::Value::Number)
+      if val.is_a?(Sass::Script::Value::Number) && val.original
         val = val.dup
         val.original = nil
       end

data/lib/sass/script/value/base.rb

@@ -30,7 +30,7 @@ module Sass::Script::Value
     #
     # @param value [Object] The object for \{#value}
     def initialize(value = nil)
-      @value = value
+      @value = value.freeze
     end
 
     # Sets the options hash for this node,

data/lib/sass/script/value/color.rb

@@ -14,13 +14,33 @@ module Sass::Script::Value
   # If only the alpha channel is modified using \{#with},
   # the cached RGB and HSL values are retained.
   class Color < Base
-    class << self; include Sass::Util; end
+    # @private
+    #
+    # Convert a ruby integer to a rgba components
+    # @param color [Fixnum]
+    # @return [Array<Fixnum>] Array of 4 numbers representing r,g,b and alpha
+    def self.int_to_rgba(color)
+      rgba = (0..3).map {|n| color >> (n << 3) & 0xff}.reverse
+      rgba[-1] = rgba[-1] / 255.0
+      rgba
+    end
+
+    ALTERNATE_COLOR_NAMES = Sass::Util.map_vals({
+        'aqua'                 => 0x00FFFFFF,
+        'darkgrey'             => 0xA9A9A9FF,
+        'darkslategrey'        => 0x2F4F4FFF,
+        'dimgrey'              => 0x696969FF,
+        'fuchsia'              => 0xFF00FFFF,
+        'grey'                 => 0x808080FF,
+        'lightgrey'            => 0xD3D3D3FF,
+        'lightslategrey'       => 0x778899FF,
+        'slategrey'            => 0x708090FF,
+    }, &method(:int_to_rgba))
 
     # A hash from color names to `[red, green, blue]` value arrays.
-    COLOR_NAMES = map_vals(
+    COLOR_NAMES = Sass::Util.map_vals({
         'aliceblue'            => 0xF0F8FFFF,
         'antiquewhite'         => 0xFAEBD7FF,
-        'aqua'                 => 0x00FFFFFF,
         'aquamarine'           => 0x7FFFD4FF,
         'azure'                => 0xF0FFFFFF,
         'beige'                => 0xF5F5DCFF,
@@ -43,7 +63,6 @@ module Sass::Script::Value
         'darkcyan'             => 0x008B8BFF,
         'darkgoldenrod'        => 0xB8860BFF,
         'darkgray'             => 0xA9A9A9FF,
-        'darkgrey'             => 0xA9A9A9FF,
         'darkgreen'            => 0x006400FF,
         'darkkhaki'            => 0xBDB76BFF,
         'darkmagenta'          => 0x8B008BFF,
@@ -55,24 +74,20 @@ module Sass::Script::Value
         'darkseagreen'         => 0x8FBC8FFF,
         'darkslateblue'        => 0x483D8BFF,
         'darkslategray'        => 0x2F4F4FFF,
-        'darkslategrey'        => 0x2F4F4FFF,
         'darkturquoise'        => 0x00CED1FF,
         'darkviolet'           => 0x9400D3FF,
         'deeppink'             => 0xFF1493FF,
         'deepskyblue'          => 0x00BFFFFF,
         'dimgray'              => 0x696969FF,
-        'dimgrey'              => 0x696969FF,
         'dodgerblue'           => 0x1E90FFFF,
         'firebrick'            => 0xB22222FF,
         'floralwhite'          => 0xFFFAF0FF,
         'forestgreen'          => 0x228B22FF,
-        'fuchsia'              => 0xFF00FFFF,
         'gainsboro'            => 0xDCDCDCFF,
         'ghostwhite'           => 0xF8F8FFFF,
         'gold'                 => 0xFFD700FF,
         'goldenrod'            => 0xDAA520FF,
         'gray'                 => 0x808080FF,
-        'grey'                 => 0x808080FF,
         'green'                => 0x008000FF,
         'greenyellow'          => 0xADFF2FFF,
         'honeydew'             => 0xF0FFF0FF,
@@ -91,13 +106,11 @@ module Sass::Script::Value
         'lightgoldenrodyellow' => 0xFAFAD2FF,
         'lightgreen'           => 0x90EE90FF,
         'lightgray'            => 0xD3D3D3FF,
-        'lightgrey'            => 0xD3D3D3FF,
         'lightpink'            => 0xFFB6C1FF,
         'lightsalmon'          => 0xFFA07AFF,
         'lightseagreen'        => 0x20B2AAFF,
         'lightskyblue'         => 0x87CEFAFF,
         'lightslategray'       => 0x778899FF,
-        'lightslategrey'       => 0x778899FF,
         'lightsteelblue'       => 0xB0C4DEFF,
         'lightyellow'          => 0xFFFFE0FF,
         'lime'                 => 0x00FF00FF,
@@ -150,7 +163,6 @@ module Sass::Script::Value
         'skyblue'              => 0x87CEEBFF,
         'slateblue'            => 0x6A5ACDFF,
         'slategray'            => 0x708090FF,
-        'slategrey'            => 0x708090FF,
         'snow'                 => 0xFFFAFAFF,
         'springgreen'          => 0x00FF7FFF,
         'steelblue'            => 0x4682B4FF,
@@ -166,14 +178,14 @@ module Sass::Script::Value
         'whitesmoke'           => 0xF5F5F5FF,
         'yellow'               => 0xFFFF00FF,
         'yellowgreen'          => 0x9ACD32FF
-      ) do |color|
-        rgba = (0..3).map {|n| color >> (n << 3) & 0xff}.reverse
-        rgba[-1] = rgba[-1] / 255.0
-        rgba
-      end
+     }, &method(:int_to_rgba))
 
     # A hash from `[red, green, blue, alpha]` value arrays to color names.
-    COLOR_NAMES_REVERSE = map_hash(hash_to_a(COLOR_NAMES)) {|k, v| [v, k]}
+    COLOR_NAMES_REVERSE = COLOR_NAMES.invert.freeze
+
+    # We add the alternate color names after inverting because
+    # different ruby implementations and versions vary on the ordering of the result of invert.
+    COLOR_NAMES.update(ALTERNATE_COLOR_NAMES).freeze
 
     # Constructs an RGB or HSL color object,
     # optionally with an alpha channel.

data/lib/sass/script/value/list.rb

@@ -52,7 +52,7 @@ module Sass::Script::Value
     def to_sass(opts = {})
       return "()" if value.empty?
       precedence = Sass::Script::Parser.precedence_of(separator)
-      members = value.reject {|e| e.is_a?(Null)}.map do |v|
+      members = value.map do |v|
         if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
             separator == :space && v.is_a?(Sass::Script::Tree::UnaryOperation) &&
             (v.operator == :minus || v.operator == :plus)

data/lib/sass/script/value/number.rb

@@ -276,7 +276,14 @@ module Sass::Script::Value
     # @return [String] The representation
     def inspect(opts = {})
       value = self.class.round(self.value)
-      unitless? ? value.to_s : "#{value}#{unit_str}"
+      str = value.to_s
+
+      # Ruby will occasionally print in scientific notation if the number is
+      # small enough. That's technically valid CSS, but it's not well-supported
+      # and confusing.
+      str = ("%0.#{self.class.precision}f" % value).gsub(/0*$/, '') if str.include?('e')
+
+      unitless? ? str : "#{str}#{unit_str}"
     end
     alias_method :to_sass, :inspect
 

data/lib/sass/scss/parser.rb

@@ -1092,11 +1092,11 @@ MESSAGE
       end
 
       def _interp_string(type)
-        start = tok(Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[[type, false]])
+        start = tok(Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][false])
         return unless start
         res = [start]
 
-        mid_re = Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[[type, true]]
+        mid_re = Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][true]
         # @scanner[2].empty? means we've started an interpolated section
         while @scanner[2] == '#{'
           @scanner.pos -= 2 # Don't consume the #{