sass 3.2.0.alpha.35 → 3.2.0.alpha.49

data/README.md

@@ -54,7 +54,7 @@ To do so, just add
 
 to `config.ru`.
 Then any Sass files in `public/stylesheets/sass`
-will be compiled CSS files in `public/stylesheets` on every request.
+will be compiled into CSS files in `public/stylesheets` on every request.
 
 To use Sass programatically,
 check out the [YARD documentation](http://sass-lang.com/docs/yardoc/).

data/REVISION

@@ -1 +1 @@
-ac7e4266b54b32610016a4b8b651c9d4e18b1e62
+70a3b0e1abd689bf4f11749f3347e39e9d1c28fb

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.35
+3.2.0.alpha.49

data/lib/sass.rb

@@ -17,6 +17,28 @@ require 'sass/version'
 #
 # Also see the {file:SASS_REFERENCE.md full Sass reference}.
 module Sass
+  # 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].
+  # They are lower-precedence than any load paths passed in via the
+  # {file:SASS_REFERENCE.md#load_paths-option `:load_paths` option}.
+  #
+  # If the `SASS_PATH` environment variable is set,
+  # the initial value of `load_paths` will be initialized based on that.
+  # The variable should be a colon-separated list of path names
+  # (semicolon-separated on Windows).
+  #
+  # Note that files on the global load path are never compiled to CSS
+  # themselves, even if they aren't partials. They exist only to be imported.
+  #
+  # @example
+  #   Sass.load_paths << File.dirname(__FILE__ + '/sass')
+  # @return [Array<String, Pathname, Sass::Importers::Base>]
+  def self.load_paths
+    @load_paths ||= ENV['SASS_PATH'] ?
+      ENV['SASS_PATH'].split(Sass::Util.windows? ? ';' : ':') : []
+  end
+
   # Compile a Sass or SCSS string to CSS.
   # Defaults to SCSS.
   #

data/lib/sass/engine.rb

@@ -173,7 +173,7 @@ module Sass
       # for quite a long time.
       options[:line_comments] ||= options[:line_numbers]
 
-      options[:load_paths] = options[:load_paths].map do |p|
+      options[:load_paths] = (options[:load_paths] + Sass.load_paths).map do |p|
         next p unless p.is_a?(String) || (defined?(Pathname) && p.is_a?(Pathname))
         options[:filesystem_importer].new(p.to_s)
       end
@@ -692,7 +692,7 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         Tree::CharsetNode.new(name)
       elsif directive == "media"
-        Tree::MediaNode.new(value)
+        Tree::MediaNode.new(value.split(',').map {|s| s.strip})
       else
         Tree::DirectiveNode.new(line.text)
       end

data/lib/sass/environment.rb

@@ -25,7 +25,6 @@ module Sass
     # @param parent [Environment] See \{#parent}
     def initialize(parent = nil)
       @parent = parent
-      set_var("important", Script::String.new("!important")) unless parent
     end
 
     # The environment of the caller of this environment's mixin or function.

data/lib/sass/exec.rb

@@ -389,7 +389,7 @@ MSG
         dirs.map! {|from, to| [from, to || from]}
         ::Sass::Plugin.options[:template_location] = dirs
 
-        ::Sass::Plugin.on_updating_stylesheet do |_, css|
+        ::Sass::Plugin.on_updated_stylesheet do |_, css|
           if File.exists? css
             puts_action :overwrite, :yellow, css
           else

data/lib/sass/importers/filesystem.rb

@@ -108,7 +108,7 @@ module Sass
       # @return [(String, Symbol)] A filename-syntax pair.
       def find_real_file(dir, name)
         for (f,s) in possible_files(remove_root(name))
-          path = (dir == ".") ? f : "#{dir}/#{f}"
+          path = (dir == "." || Pathname.new(f).absolute?) ? f : "#{dir}/#{f}"
           if full_path = Dir[path].first
             full_path.gsub!(REDUNDANT_DIRECTORY,File::SEPARATOR)
             return full_path, s

data/lib/sass/plugin.rb

@@ -92,14 +92,10 @@ module Sass
     #   the second is the location of the CSS file that it should be compiled to.
     # @see #update_stylesheets
     def force_update_stylesheets(individual_files = [])
-      old_options = options
-      self.options = options.dup
-      options[:never_update] = false
-      options[:always_update] = true
-      options[:cache] = false
-      update_stylesheets(individual_files)
-    ensure
-      self.options = old_options
+      Compiler.new(options.dup.merge(
+          :never_update => false,
+          :always_update => true,
+          :cache => false)).update_stylesheets(individual_files)
     end
 
     # All other method invocations are proxied to the \{#compiler}.

data/lib/sass/plugin/compiler.rb

@@ -38,7 +38,7 @@ module Sass::Plugin
       self.options.merge!(options)
     end
 
-    # Register a callback to be run before stylesheets are mass-updated.
+    # Register a callback to be run after stylesheets are mass-updated.
     # This is run whenever \{#update\_stylesheets} is called,
     # unless the \{file:SASS_REFERENCE.md#never_update-option `:never_update` option}
     # is enabled.
@@ -51,6 +51,22 @@ module Sass::Plugin
     #   the second is the target CSS file.
     define_callback :updating_stylesheets
 
+    # Register a callback to be run after a single stylesheet is updated.
+    # The callback is only run if the stylesheet is really updated;
+    # if the CSS file is fresh, this won't be run.
+    #
+    # Even if the \{file:SASS_REFERENCE.md#full_exception-option `:full_exception` option}
+    # is enabled, this callback won't be run
+    # when an exception CSS file is being written.
+    # To run an action for those files, use \{#on\_compilation\_error}.
+    #
+    # @yield [template, css]
+    # @yieldparam template [String]
+    #   The location of the Sass/SCSS file being updated.
+    # @yieldparam css [String]
+    #   The location of the CSS file being generated.
+    define_callback :updated_stylesheet
+
     # Register a callback to be run before a single stylesheet is updated.
     # The callback is only run if the stylesheet is guaranteed to be updated;
     # if the CSS file is fresh, this won't be run.
@@ -67,6 +83,13 @@ module Sass::Plugin
     #   The location of the CSS file being generated.
     define_callback :updating_stylesheet
 
+    def on_updating_stylesheet_with_deprecation_warning(&block)
+      Sass::Util.sass_warn("Sass::Compiler#on_updating_stylesheet callback is deprecated and will be removed in a future release. Use Sass::Compiler#on_updated_stylesheet instead, which is run after stylesheet compilation.")
+      on_updating_stylesheet_without_deprecation_warning(&block)
+    end
+    alias_method :on_updating_stylesheet_without_deprecation_warning, :on_updating_stylesheet
+    alias_method :on_updating_stylesheet, :on_updating_stylesheet_with_deprecation_warning
+
     # Register a callback to be run when Sass decides not to update a stylesheet.
     # In particular, the callback is run when Sass finds that
     # the template file and none of its dependencies
@@ -160,28 +183,25 @@ module Sass::Plugin
     #   The first string in each pair is the location of the Sass/SCSS file,
     #   the second is the location of the CSS file that it should be compiled to.
     def update_stylesheets(individual_files = [])
-      run_updating_stylesheets individual_files
       Sass::Plugin.checked_for_updates = true
       staleness_checker = StalenessChecker.new(engine_options)
 
-      individual_files.each do |t, c|
-        if options[:always_update] || staleness_checker.stylesheet_needs_update?(c, t)
-          update_stylesheet(t, c)
-        end
-      end
-
       template_location_array.each do |template_location, css_location|
-
         Dir.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
           # Get the relative path to the file
           name = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
           css = css_filename(name, css_location)
+          individual_files << [file, css]
+        end
+      end
 
-          if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
-            update_stylesheet file, css
-          else
-            run_not_updating_stylesheet file, css
-          end
+      run_updating_stylesheets individual_files
+
+      individual_files.each do |file, css|
+        if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
+          update_stylesheet(file, css)
+        else
+          run_not_updating_stylesheet(file, css)
         end
       end
     end
@@ -318,18 +338,23 @@ module Sass::Plugin
         engine_opts = engine_options(:css_filename => css, :filename => filename)
         result = Sass::Engine.for_file(filename, engine_opts).render
       rescue Exception => e
+        compilation_error_occured = true
         run_compilation_error e, filename, css
         result = Sass::SyntaxError.exception_to_css(e, options)
       else
         run_updating_stylesheet filename, css
       end
 
-      # Finally, write the file
+      write_file(css, result)
+      run_updated_stylesheet(filename, css) unless compilation_error_occured
+    end
+
+    def write_file(css, content)
       flag = 'w'
       flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
       File.open(css, flag) do |file|
-        file.set_encoding(result.encoding) unless Sass::Util.ruby1_8?
-        file.print(result)
+        file.set_encoding(content.encoding) unless Sass::Util.ruby1_8?
+        file.print(content)
       end
     end
 

data/lib/sass/plugin/configuration.rb

@@ -31,8 +31,6 @@ module Sass
       # @return [{Symbol => Object}]
       def options
         @options ||= default_options.dup
-        @options[:cache_store] ||= Sass::CacheStores::Filesystem.new(@options[:cache_location])
-        @options
       end
 
       # Sets the options hash.

data/lib/sass/repl.rb

@@ -15,7 +15,6 @@ module Sass
     # Starts the read-eval-print loop.
     def run
       environment = Environment.new
-      environment.set_var('important', Script::String.new('!important'))
       @line = 0
       loop do
         @line += 1

data/lib/sass/script/funcall.rb

@@ -88,7 +88,12 @@ module Sass
           opts(Functions::EvaluationContext.new(environment.options).send(ruby_name, *args))
         end
       rescue ArgumentError => e
-        raise e unless e.backtrace.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
+        # 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}'$/
+          raise e
+        end
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
       end
 

data/lib/sass/script/functions.rb

@@ -93,7 +93,7 @@ module Sass::Script
   # \{#adjust_color adjust-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Increase or decrease any of the components of a color.
   #
-  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Fluidly scale one or more components of a color.
   #
   # \{#change_color change-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
@@ -968,7 +968,7 @@ module Sass::Script
       #
       # Finally, the weight of color1 is renormalized to be within [0, 1]
       # and the weight of color2 is given by 1 minus the weight of color1.
-      p = weight.value/100.0
+      p = (weight.value/100.0).to_f
       w = p*2 - 1
       a = color1.alpha - color2.alpha
 

data/lib/sass/script/number.rb

@@ -360,7 +360,7 @@ module Sass::Script
       elsif num % 1 == 0.0
         num.to_i
       else
-        (num * self.precision_factor).round / self.precision_factor
+        ((num * self.precision_factor).round / self.precision_factor).to_f
       end
     end
 

data/lib/sass/script/parser.rb

@@ -182,7 +182,11 @@ module Sass
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}) and return interp
               return unless e = #{sub}
               while tok = try_tok(#{ops.map {|o| o.inspect}.join(', ')})
-                interp = try_op_before_interp(tok, e) and return interp
+                if interp = try_op_before_interp(tok, e)
+                  return interp unless other_interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}, interp)
+                  return other_interp
+                end
+
                 line = @lexer.line
                 e = Operation.new(e, assert_expr(#{sub.inspect}), tok.type)
                 e.line = line
@@ -217,7 +221,10 @@ RUBY
         return unless e = interpolation
         arr = [e]
         while tok = try_tok(:comma)
-          interp = try_op_before_interp(tok, e) and return interp
+          if interp = try_op_before_interp(tok, e)
+            return interp unless other_interp = try_ops_after_interp([:comma], :expr, interp)
+            return other_interp
+          end
           arr << assert_expr(:interpolation)
         end
         arr.size == 1 ? arr.first : node(List.new(arr, :comma), line)
@@ -235,15 +242,15 @@ RUBY
         interpolation(interp)
       end
 
-      def try_ops_after_interp(ops, name)
+      def try_ops_after_interp(ops, name, prev = nil)
         return unless @lexer.after_interpolation?
         return unless op = try_tok(*ops)
-        interp = try_op_before_interp(op) and return interp
+        interp = try_op_before_interp(op, prev) and return interp
 
         wa = @lexer.whitespace?
         str = Script::String.new(Lexer::OPERATORS_REVERSE[op.type])
         str.line = @lexer.line
-        interp = Script::Interpolation.new(nil, str, assert_expr(name), !:wb, wa, :originally_text)
+        interp = Script::Interpolation.new(prev, str, assert_expr(name), !:wb, wa, :originally_text)
         interp.line = @lexer.line
         return interp
       end

data/lib/sass/script/variable.rb

@@ -21,7 +21,6 @@ module Sass
 
       # @return [String] A string representation of the variable
       def inspect(opts = {})
-        return "!important" if name == "important"
         "$#{dasherize(name, opts)}"
       end
       alias_method :to_sass, :inspect

data/lib/sass/scss/css_parser.rb

@@ -18,6 +18,7 @@ module Sass
 
       private
 
+      def placeholder_selector; nil; end
       def parent_selector; nil; end
       def interpolation; nil; end
       def interp_string; tok(STRING); end

data/lib/sass/scss/parser.rb

@@ -294,20 +294,23 @@ module Sass
       def use_css_import?; false; end
 
       def media_directive
-        val = str {media_query_list}.strip
-        block(node(Sass::Tree::MediaNode.new(val)), :directive)
+        block(node(Sass::Tree::MediaNode.new(media_query_list)), :directive)
       end
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
       def media_query_list
-        return unless media_query
+        has_q = false
+        q = str {has_q = media_query}
+
+        return unless has_q
+        queries = [q.strip]
 
         ss
         while tok(/,/)
-          ss; expr!(:media_query); ss
+          ss; queries << str {expr!(:media_query)}.strip; ss
         end
 
-        true
+        queries
       end
 
       def media_query
@@ -444,7 +447,7 @@ module Sass
       end
 
       def selector_sequence
-        if sel = tok(STATIC_SELECTOR)
+        if sel = tok(STATIC_SELECTOR, true)
           return [sel]
         end
 
@@ -506,12 +509,14 @@ module Sass
       def simple_selector_sequence
         # This allows for stuff like http://www.w3.org/TR/css3-animations/#keyframes-
         return expr unless e = element_name || id_selector || class_selector ||
-          attrib || negation || pseudo || parent_selector || interpolation_selector
+          placeholder_selector || attrib || negation || pseudo || parent_selector ||
+          interpolation_selector
         res = [e]
 
         # The tok(/\*/) allows the "E*" hack
-        while v = id_selector || class_selector || attrib || negation || pseudo ||
-            interpolation_selector || (tok(/\*/) && Selector::Universal.new(nil))
+        while v = id_selector || class_selector || placeholder_selector || attrib ||
+            negation || pseudo || interpolation_selector ||
+            (tok(/\*/) && Selector::Universal.new(nil))
           res << v
         end
 
@@ -521,6 +526,9 @@ module Sass
           @scanner.pos = pos
           @line = line
           begin
+            # If we see "*E", don't force a throw because this could be the
+            # "*prop: val" hack.
+            expected('"{"') if res.length == 1 && res[0].is_a?(Selector::Universal)
             throw_error {expected('"{"')}
           rescue Sass::SyntaxError => e
             e.message << "\n\n\"#{sel}\" may only be used at the beginning of a selector."
@@ -548,6 +556,12 @@ module Sass
         Selector::Id.new(merge(expr!(:interp_name)))
       end
 
+      def placeholder_selector
+        return unless tok(/%/)
+        @expected = "placeholder name"
+        Selector::Placeholder.new(merge(expr!(:interp_ident)))
+      end
+
       def element_name
         return unless name = interp_ident || tok(/\*/) || (tok?(/\|/) && "")
         if tok(/\|/)
@@ -679,7 +693,7 @@ module Sass
         # we don't parse it at all, and instead return a plain old string
         # containing the value.
         # This results in a dramatic speed increase.
-        if val = tok(STATIC_VALUE)
+        if val = tok(STATIC_VALUE, true)
           return space, Sass::Script::String.new(val.strip)
         end
         return space, sass_script(:parse)
@@ -768,7 +782,7 @@ MESSAGE
       end
 
       def interp_ident(start = IDENT)
-        return unless val = tok(start) || interpolation
+        return unless val = tok(start) || interpolation || tok(IDENT_HYPHEN_INTERP, true)
         res = [val]
         while val = tok(NAME) || interpolation
           res << val
@@ -938,9 +952,20 @@ MESSAGE
       # This is important because `#tok` is called all the time.
       NEWLINE = "\n"
 
-      def tok(rx)
+      def tok(rx, last_group_lookahead = false)
         res = @scanner.scan(rx)
         if res
+          # This fixes https://github.com/nex3/sass/issues/104, which affects
+          # Ruby 1.8.7 and REE. This fix is to replace the ?= zero-width
+          # positive lookahead operator in the Regexp (which matches without
+          # consuming the matched group), with a match that does consume the
+          # group, but then rewinds the scanner and removes the group from the
+          # end of the matched string. This fix makes the assumption that the
+          # matched group will always occur at the end of the match.
+          if last_group_lookahead && @scanner[-1]
+            @scanner.pos -= @scanner[-1].length
+            res.slice!(-@scanner[-1].length..-1)
+          end
           @line += res.count(NEWLINE)
           @expected = nil
           if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT