haml 2.2.24 → 3.0.0.beta.1

data/lib/sass/environment.rb

@@ -43,10 +43,16 @@ module Sass
       def inherited_hash(name)
         class_eval <<RUBY, __FILE__, __LINE__ + 1
           def #{name}(name)
-            @#{name}s[name] || @parent && @parent.#{name}(name)
+            _#{name}(name.gsub('_', '-'))
           end
 
+          def _#{name}(name)
+            @#{name}s[name] || @parent && @parent._#{name}(name)
+          end
+          protected :_#{name}
+
           def set_#{name}(name, value)
+            name = name.gsub('_', '-')
             @#{name}s[name] = value unless try_set_#{name}(name, value)
           end
 
@@ -63,7 +69,7 @@ module Sass
           protected :try_set_#{name}
 
           def set_local_#{name}(name, value)
-            @#{name}s[name] = value
+            @#{name}s[name.gsub('_', '-')] = value
           end
 RUBY
       end

data/lib/sass/error.rb

@@ -4,51 +4,189 @@ module Sass
   # and the Sass file that was being parsed (if applicable).
   #
   # All Sass errors are raised as {Sass::SyntaxError}s.
+  #
+  # When dealing with SyntaxErrors,
+  # it's important to provide filename and line number information.
+  # This will be used in various error reports to users, including backtraces;
+  # see \{#sass\_backtrace} for details.
+  #
+  # Some of this information is usually provided as part of the constructor.
+  # New backtrace entries can be added with \{#add\_backtrace},
+  # which is called when an exception is raised between files (e.g. with `@import`).
+  #
+  # Often, a chunk of code will all have similar backtrace information -
+  # the same filename or even line.
+  # It may also be useful to have a default line number set.
+  # In those situations, the default values can be used
+  # by omitting the information on the original exception,
+  # and then calling \{#modify\_backtrace} in a wrapper `rescue`.
+  # When doing this, be sure that all exceptions ultimately end up
+  # with the information filled in.
   class SyntaxError < StandardError
-    # The line of the Sass template on which the error occurred.
+    # The backtrace of the error within Sass files.
+    # This is an array of hashes containing information for a single entry.
+    # The hashes have the following keys:
     #
-    # @return [Fixnum]
-    attr_accessor :sass_line
+    # `:filename`
+    # : The name of the file in which the exception was raised,
+    #   or `nil` if no filename is available.
+    #
+    # `:mixin`
+    # : The name of the mixin in which the exception was raised,
+    #   or `nil` if it wasn't raised in a mixin.
+    #
+    # `:line`
+    # : The line of the file on which the error occurred. Never nil.
+    #
+    # This information is also included in standard backtrace format
+    # in the output of \{#backtrace}.
+    #
+    # @return [Aray<{Symbol => Object>}]
+    attr_accessor :sass_backtrace
 
-    # The name of the file that was being parsed when the exception was raised.
-    # This could be `nil` if no filename is available.
+    # The text of the template where this error was raised.
     #
     # @return [String]
-    attr_reader :sass_filename
+    attr_accessor :sass_template
 
     # @param msg [String] The error message
-    # @param lineno [Fixnum] See \{#sass\_line}
-    def initialize(msg, lineno = nil)
+    # @param attrs [{Symbol => Object}] The information in the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def initialize(msg, attrs = {})
       @message = msg
-      @sass_line = lineno
+      @sass_backtrace = []
+      add_backtrace(attrs)
+    end
+
+    # The name of the file in which the exception was raised.
+    # This could be `nil` if no filename is available.
+    #
+    # @return [String, nil]
+    def sass_filename
+      sass_backtrace.first[:filename]
+    end
+
+    # The name of the mixin in which the error occurred.
+    # This could be `nil` if the error occurred outside a mixin.
+    #
+    # @return [Fixnum]
+    def sass_mixin
+      sass_backtrace.first[:mixin]
+    end
+
+    # The line of the Sass template on which the error occurred.
+    #
+    # @return [Fixnum]
+    def sass_line
+      sass_backtrace.first[:line]
     end
 
-    # Add information about the filename and line on which the error was raised,
-    # and re-raises the exception.
+    # Adds an entry to the exception's Sass backtrace.
     #
-    # @param filename [String] See \{#sass\_filename}
-    # @param line [Fixnum] See \{#sass\_line}
-    # @raise [Sass::SyntaxError] self
-    def add_metadata(filename, line)
-      self.sass_line ||= line
-      add_backtrace_entry(filename) unless sass_filename
-      raise self
+    # @param attrs [{Symbol => Object}] The information in the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def add_backtrace(attrs)
+      sass_backtrace << attrs.reject {|k, v| v.nil?}
     end
 
-    # Adds a properly formatted entry to the exception's backtrace.
+    # Modify the top Sass backtrace entries
+    # (that is, the most deeply nested ones)
+    # to have the given attributes.
     #
-    # @param filename [String] The file in which the error occurred,
-    #   if applicable (defaults to "(sass)")
-    def add_backtrace_entry(filename) # :nodoc:
-      @sass_filename ||= filename
-      self.backtrace ||= []
-      self.backtrace.unshift "#{@sass_filename || '(sass)'}:#{@sass_line}"
+    # Specifically, this goes through the backtrace entries
+    # from most deeply nested to least,
+    # setting the given attributes for each entry.
+    # If an entry already has one of the given attributes set,
+    # the pre-existing attribute takes precedence
+    # and is not used for less deeply-nested entries
+    # (even if they don't have that attribute set).
+    #
+    # @param attrs [{Symbol => Object}] The information to add to the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def modify_backtrace(attrs)
+      attrs = attrs.reject {|k, v| v.nil?}
+      # Move backwards through the backtrace
+      (0...sass_backtrace.size).to_a.reverse.each do |i|
+        entry = sass_backtrace[i]
+        sass_backtrace[i] = attrs.merge(entry)
+        attrs.reject! {|k, v| entry.include?(k)}
+        break if attrs.empty?
+      end
     end
 
     # @return [String] The error message
     def to_s
       @message
     end
+
+    # Returns the standard exception backtrace,
+    # including the Sass backtrace.
+    #
+    # @return [Array<String>]
+    def backtrace
+      return nil if super.nil?
+      sass_backtrace.map do |h|
+        "#{h[:filename] || "(sass)"}:#{h[:line]}" +
+          (h[:mixin] ? ":in `#{h[:mixin]}'" : "")
+      end + super
+    end
+
+    # Returns a string representation of the Sass backtrace.
+    #
+    # @param default_filename [String] The filename to use for unknown files
+    # @see #sass_backtrace
+    # @return [String]
+    def sass_backtrace_str(default_filename = "an unknown file")
+      "Syntax error: #{message}" +
+        Haml::Util.enum_with_index(sass_backtrace).map do |entry, i|
+        "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
+          " of #{entry[:filename] || default_filename}" +
+          (entry[:mixin] ? ", in `#{entry[:mixin]}'" : "")
+      end.join
+    end
+
+    class << self
+      # Returns an error report for an exception in CSS format.
+      #
+      # @param e [Exception]
+      # @param options [{Symbol => Object}] The options passed to {Sass::Engine#initialize}
+      # @return [String] The error report
+      # @raise [Exception] `e`, if the
+      #   {file:SASS_REFERENCE.md#full_exception-option `:full_exception`} option
+      #   is set to false.
+      def exception_to_css(e, options)
+        raise e unless options[:full_exception]
+
+        header = header_string(e, options)
+
+        <<END
+/*
+#{header}
+
+Backtrace:\n#{e.backtrace.join("\n")}
+*/
+body:before {
+  white-space: pre;
+  font-family: monospace;
+  content: "#{header.gsub('"', '\"').gsub("\n", '\\A ')}"; }
+END
+      end
+
+      private
+
+      def header_string(e, options)
+        return "#{e.class}: #{e.message}" unless e.is_a? Sass::SyntaxError
+
+        line_offset = options[:line] || 1
+        line_num = e.sass_line + 1 - line_offset
+        min = [line_num - 6, 0].max
+        section = e.sass_template.rstrip.split("\n")[min ... line_num + 5]
+        return e.sass_backtrace_str if section.nil? || section.empty?
+
+        e.sass_backtrace_str + "\n\n" + Haml::Util.enum_with_index(section).
+          map {|line, i| "#{line_offset + min + i}: #{line}"}.join("\n")
+      end
+    end
   end
 
   # The class for Sass errors that are raised due to invalid unit conversions

data/lib/sass/files.rb

@@ -11,10 +11,11 @@ module Sass
     # Returns the {Sass::Tree} for the given file,
     # reading it from the Sass cache if possible.
     #
-    # @param filename [String] The path to the Sass file
+    # @param filename [String] The path to the Sass or SCSS file
     # @param options [{Symbol => Object}] The options hash.
     #   Only the {file:SASS_REFERENCE.md#cache-option `:cache_location`} option is used
-    # @raise [Sass::SyntaxError] if there's an error in the document
+    # @raise [Sass::SyntaxError] if there's an error in the document.
+    #   The caller has responsibility for setting backtrace information, if necessary
     def tree_for(filename, options)
       options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
       text = File.read(filename)
@@ -29,57 +30,59 @@ module Sass
         end
       end
 
-      engine = Sass::Engine.new(text, options.merge(:filename => filename))
-
-      begin
-        root = engine.to_tree
-      rescue Sass::SyntaxError => err
-        err.add_backtrace_entry(filename)
-        raise err
+      options = options.merge(:filename => filename)
+      if filename =~ /\.scss$/
+        options = options.merge(:syntax => :scss)
+      elsif filename =~ /\.sass$/
+        options = options.merge(:syntax => :sass)
       end
 
-      try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
+      engine = Sass::Engine.new(text, options)
 
+      root = engine.to_tree
+      try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
       root
     end
 
-    # Find the full filename of a Sass or CSS file to import.
+    # Find the full filename of a Sass, SCSS, or CSS file to import.
     # This follows Sass's import rules:
-    # if the filename given ends in `".sass"` or `".css"`,
+    # if the filename given ends in `".sass"`, `".scss"`, or `".css"`,
     # it will try to find that type of file;
-    # otherwise, it will try to find the corresponding Sass file
+    # otherwise, it will try to find the corresponding Sass/SCSS file
     # and fall back on CSS if it's not available.
     #
-    # Any Sass filename returned will correspond to
-    # an actual Sass file on the filesystem.
+    # Any Sass/SCSS filename returned will correspond to
+    # an actual file of the corresponding type on the filesystem.
     # CSS filenames, however, may not;
     # they're expected to be put through directly to the stylesheet
     # as CSS `@import` statements.
     #
     # @param filename [String] The filename to search for
     # @param load_paths [Array<String>] The set of filesystem paths
-    #   to search for Sass files.
+    #   to search for Sass/SCSS files.
     # @return [String] The filename of the imported file.
-    #   This is an absolute path if the file is a `".sass"` file.
-    # @raise [Sass::SyntaxError] if `filename` ends in ``".sass"``
-    #   and no corresponding Sass file could be found.
+    #   This is an absolute path if the file is a `".sass"` or `".scss"` file.
+    # @raise [Sass::SyntaxError] if `filename` ends in `".sass"` or `".scss"`
+    #   and no corresponding Sass/SCSS file could be found.
     def find_file_to_import(filename, load_paths)
-      was_sass = false
+      was_sass = was_scss = false
       original_filename = filename
 
-      if filename[-5..-1] == ".sass"
+      if [".sass", ".scss"].include?(filename[-5..-1])
+        was_sass = filename[-5..-1] == ".sass"
+        was_scss = filename[-5..-1] == ".scss"
         filename = filename[0...-5]
-        was_sass = true
       elsif filename[-4..-1] == ".css"
         return filename
       end
 
-      new_filename = find_full_path("#{filename}.sass", load_paths)
+      new_filename   = find_full_path("#{filename}.sass", load_paths) unless was_scss
+      new_filename ||= find_full_path("#{filename}.scss", load_paths) unless was_sass
 
       return new_filename if new_filename
-      unless was_sass
-        warn <<END
-WARNING: #{filename}.sass not found. Using #{filename}.css instead.
+      unless was_sass || was_scss
+        Haml::Util.haml_warn <<END
+WARNING: Neither #{filename}.sass nor .scss found. Using #{filename}.css instead.
 This behavior is deprecated and will be removed in a future version.
 If you really need #{filename}.css, import it explicitly.
 END
@@ -93,7 +96,7 @@ END
         message << "Load paths:\n  " << load_paths.join("\n  ")
       end
 
-      raise SyntaxError.new(message, @line)
+      raise SyntaxError.new(message)
     end
 
     private
@@ -113,7 +116,7 @@ END
         return Marshal.load(f.read)
       end
     rescue EOFError, TypeError, ArgumentError => e
-      warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
+      Haml::Util.haml_warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
     end
 
     def try_to_write_sassc(root, compiled_filename, sha, options)

data/lib/sass/plugin.rb

@@ -1,8 +1,11 @@
-require 'sass'
+require 'fileutils'
 require 'rbconfig'
 
+require 'sass'
+require 'sass/callbacks'
+
 module Sass
-  # This module handles the compilation of Sass files.
+  # This module handles the compilation of Sass/SCSS files.
   # It provides global options and checks whether CSS files
   # need to be updated.
   #
@@ -11,7 +14,23 @@ module Sass
   # All Rack-enabled frameworks are supported out of the box.
   # The plugin is {file:SASS_REFERENCE.md#rails_merb_plugin automatically activated for Rails and Merb}.
   # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
+  #
+  # This module has a large set of callbacks available
+  # to allow users to run code (such as logging) when certain things happen.
+  # All callback methods are of the form `on_#{name}`,
+  # and they all take a block that's called when the given action occurs.
+  #
+  # @example Using a callback
+  # Sass::Plugin.on_updating_stylesheet do |template, css|
+  #   puts "Compiling #{template} to #{css}"
+  # end
+  # Sass::Plugin.update_stylesheets
+  #   #=> Compiling app/sass/screen.scss to public/stylesheets/screen.css
+  #   #=> Compiling app/sass/print.scss to public/stylesheets/print.css
+  #   #=> Compiling app/sass/ie.scss to public/stylesheets/ie.css
   module Plugin
+    include Haml::Util
+    include Sass::Callbacks
     extend self
 
     @options = {
@@ -22,6 +41,114 @@ module Sass
     }
     @checked_for_updates = false
 
+    # Register a callback to be run before 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.
+    #
+    # @yield [individual_files]
+    # @yieldparam individual_files [<(String, String)>]
+    #   Individual files to be updated, in addition to the directories
+    #   specified in the options.
+    #   The first element of each pair is the source file,
+    #   the second is the target CSS file.
+    define_callback :updating_stylesheets
+
+    # 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.
+    #
+    # 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 :updating_stylesheet
+
+    # 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
+    # have been modified since the last compilation.
+    #
+    # Note that this is **not** run when the
+    # \{file:SASS_REFERENCE.md#never-update_option `:never_update` option} is set,
+    # nor when Sass decides not to compile a partial.
+    #
+    # @yield [template, css]
+    # @yieldparam template [String]
+    #   The location of the Sass/SCSS file not being updated.
+    # @yieldparam css [String]
+    #   The location of the CSS file not being generated.
+    define_callback :not_updating_stylesheet
+
+    # Register a callback to be run when there's an error
+    # compiling a Sass file.
+    # This could include not only errors in the Sass document,
+    # but also errors accessing the file at all.
+    #
+    # @yield [error, template, css]
+    # @yieldparam error [Exception] The exception that was raised.
+    # @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 :compilation_error
+
+    # Register a callback to be run when Sass creates a directory
+    # into which to put CSS files.
+    #
+    # Note that even if multiple levels of directories need to be created,
+    # the callback may only be run once.
+    # For example, if "foo/" exists and "foo/bar/baz/" needs to be created,
+    # this may only be run for "foo/bar/baz/".
+    # This is not a guarantee, however;
+    # it may also be run for "foo/bar/".
+    #
+    # @yield [dirname]
+    # @yieldparam dirname [String]
+    #   The location of the directory that was created.
+    define_callback :creating_directory
+
+    # Register a callback to be run when Sass detects
+    # that a template has been modified.
+    # This is only run when using \{#watch}.
+    #
+    # @yield [template]
+    # @yieldparam template [String]
+    #   The location of the template that was modified.
+    define_callback :template_modified
+
+    # Register a callback to be run when Sass detects
+    # that a new template has been created.
+    # This is only run when using \{#watch}.
+    #
+    # @yield [template]
+    # @yieldparam template [String]
+    #   The location of the template that was created.
+    define_callback :template_created
+
+    # Register a callback to be run when Sass detects
+    # that a template has been deleted.
+    # This is only run when using \{#watch}.
+    #
+    # @yield [template]
+    # @yieldparam template [String]
+    #   The location of the template that was deleted.
+    define_callback :template_deleted
+
+    # Register a callback to be run when Sass deletes a CSS file.
+    # This happens when the corresponding Sass/SCSS file has been deleted.
+    #
+    # @yield [filename]
+    # @yieldparam filename [String]
+    #   The location of the CSS file that was deleted.
+    define_callback :deleting_css
+
     # Whether or not Sass has **ever** checked if the stylesheets need to be updated
     # (in this Ruby instance).
     #
@@ -65,61 +192,163 @@ module Sass
 
     # Updates out-of-date stylesheets.
     #
-    # Checks each Sass file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
+    # Checks each Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
     # to see if it's been modified more recently than the corresponding CSS file
     # in {file:SASS_REFERENCE.md#css_location-option `:css_location`}.
     # If it has, it updates the CSS file.
-    def update_stylesheets
+    #
+    # @param individual_files [Array<(String, String)>]
+    #   A list of files to check for updates
+    #   **in addition to those specified by the
+    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
+    #   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 = [])
       return if options[:never_update]
 
+      run_updating_stylesheets individual_files
+
+      individual_files.each {|t, c| update_stylesheet(t, c)}
+
       @checked_for_updates = true
       template_locations.zip(css_locations).each do |template_location, css_location|
 
-        Dir.glob(File.join(template_location, "**", "*.sass")).each do |file|
-          # Get the relative path to the file with no extension
-          name = file.sub(template_location.sub(/\/*$/, '/'), "")[0...-5]
+        Dir.glob(File.join(template_location, "**", "*.s[ca]ss")).each do |file|
+          # Get the relative path to the file
+          name = file.sub(template_location.sub(/\/*$/, '/'), "")
+          css = css_filename(name, css_location)
 
-          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
-            update_stylesheet(name, template_location, css_location)
+          next if forbid_update?(name)
+          if options[:always_update] || stylesheet_needs_update?(css, file)
+            update_stylesheet file, css
+          else
+            run_not_updating_stylesheet file, css
           end
         end
       end
     end
 
-    private
+    # Watches the template directory (or directories)
+    # and updates the CSS files whenever the related Sass/SCSS files change.
+    # `watch` never returns.
+    #
+    # Whenever a change is detected to a Sass/SCSS file in
+    # {file:SASS_REFERENCE.md#template_location-option `:template_location`},
+    # the corresponding CSS file in {file:SASS_REFERENCE.md#css_location-option `:css_location`}
+    # will be recompiled.
+    # The CSS files of any Sass/SCSS files that import the changed file will also be recompiled.
+    #
+    # Before the watching starts in earnest, `watch` calls \{#update\_stylesheets}.
+    #
+    # Note that `watch` uses the [FSSM](http://github.com/ttilley/fssm) library
+    # to monitor the filesystem for changes.
+    # FSSM isn't loaded until `watch` is run.
+    # The version of FSSM distributed with Sass is loaded by default,
+    # but if another version has already been loaded that will be used instead.
+    #
+    # @param individual_files [Array<(String, String)>]
+    #   A list of files to watch for updates
+    #   **in addition to those specified by the
+    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
+    #   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 watch(individual_files = [])
+      update_stylesheets(individual_files)
+
+      begin
+        require 'fssm'
+      rescue LoadError => e
+        e.message << "\n" <<
+          if File.exists?(scope(".git"))
+            'Run "git submodule update --init" to get the recommended version.'
+          else
+            'Run "gem install fssm" to get it.'
+          end
+        raise e
+      end
+
+      # TODO: Keep better track of what depends on what
+      # so we don't have to run a global update every time anything changes.
+      FSSM.monitor do |mon|
+        template_locations.zip(css_locations).each do |template_location, css_location|
+          mon.path template_location do |path|
+            path.glob '**/*.s[ac]ss'
+
+            path.update do |base, relative|
+              run_template_modified File.join(base, relative)
+              update_stylesheets(individual_files)
+            end
+
+            path.create do |base, relative|
+              run_template_created File.join(base, relative)
+              update_stylesheets(individual_files)
+            end
+
+            path.delete do |base, relative|
+              run_template_deleted File.join(base, relative)
+              css = File.join(css_location, relative.gsub(/\.s[ac]ss$/, '.css'))
+              try_delete_css css
+              update_stylesheets(individual_files)
+            end
+          end
+        end
+
+        individual_files.each do |template, css|
+          mon.file template do |path|
+            path.update do
+              run_template_modified template
+              update_stylesheets(individual_files)
+            end
+
+            path.create do
+              run_template_created template
+              update_stylesheets(individual_files)
+            end
+
+            path.delete do
+              run_template_deleted template
+              try_delete_css css
+              update_stylesheets(individual_files)
+            end
+          end
+        end
+      end
+    end
 
-    def update_stylesheet(name, template_location, css_location)
-      css = css_filename(name, css_location)
-      File.delete(css) if File.exists?(css)
+    private
 
-      filename = template_filename(name, template_location)
-      result = begin
-                 Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
-               rescue Exception => e
-                 raise e unless options[:full_exception]
-                 exception_string(e)
-               end
+    def update_stylesheet(filename, css)
+      dir = File.dirname(css)
+      unless File.exists?(dir)
+        run_creating_directory dir
+        FileUtils.mkdir_p dir
+      end
 
-      # Create any directories that might be necessary
-      mkpath(css_location, name)
+      begin
+        result = Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
+      rescue Exception => e
+        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
       flag = 'w'
       flag = 'wb' if RbConfig::CONFIG['host_os'] =~ /mswin|windows/i && options[:unix_newlines]
       File.open(css, flag) {|file| file.print(result)}
     end
-    
-    # Create any successive directories required to be able to write a file to: File.join(base,name)
-    def mkpath(base, name)
-      dirs = [base]
-      name.split(File::SEPARATOR)[0...-1].each { |dir| dirs << File.join(dirs[-1],dir) }
-      dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
+
+    def try_delete_css(css)
+      return unless File.exists?(css)
+      run_deleting_css css
+      File.delete css
     end
 
     def load_paths(opts = options)
       (opts[:load_paths] || []) + template_locations
     end
-    
+
     def template_locations
       location = (options[:template_location] || File.join(options[:css_location],'sass'))
       if location.is_a?(String)
@@ -128,7 +357,7 @@ module Sass
         location.to_a.map { |l| l.first }
       end
     end
-    
+
     def css_locations
       if options[:template_location] && !options[:template_location].is_a?(String)
         options[:template_location].to_a.map { |l| l.last }
@@ -137,65 +366,16 @@ module Sass
       end
     end
 
-    def exception_string(e)
-      e_string = "#{e.class}: #{e.message}"
-
-      if e.is_a? Sass::SyntaxError
-        e_string << "\non line #{e.sass_line}"
-
-        if e.sass_filename
-          e_string << " of #{e.sass_filename}"
-
-          if File.exists?(e.sass_filename)
-            e_string << "\n\n"
-
-            min = [e.sass_line - 5, 0].max
-            begin
-              File.read(e.sass_filename).rstrip.split("\n")[
-                min .. e.sass_line + 5
-              ].each_with_index do |line, i|
-                e_string << "#{min + i + 1}: #{line}\n"
-              end
-            rescue
-              e_string << "Couldn't read sass file: #{e.sass_filename}"
-            end
-          end
-        end
-      end
-      <<END
-/*
-#{e_string}
-
-Backtrace:\n#{e.backtrace.join("\n")}
-*/
-body:before {
-  white-space: pre;
-  font-family: monospace;
-  content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; }
-END
-      # Fix an emacs syntax-highlighting hiccup: '
-    end
-
-    def template_filename(name, path)
-      "#{path}/#{name}.sass"
-    end
-
     def css_filename(name, path)
-      "#{path}/#{name}.css"
+      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
     end
 
     def forbid_update?(name)
       name.sub(/^.*\//, '')[0] == ?_
     end
 
-    def stylesheet_needs_update?(name, template_path, css_path)
-      css_file = css_filename(name, css_path)
-      template_file = template_filename(name, template_path)
-      exact_stylesheet_needs_update?(css_file, template_file)
-    end
-
-    def exact_stylesheet_needs_update?(css_file, template_file)
-      return true unless File.exists?(css_file)
+    def stylesheet_needs_update?(css_file, template_file)
+      return true unless File.exists?(css_file) && File.exists?(template_file)
 
       css_mtime = File.mtime(css_file)
       File.mtime(template_file) > css_mtime ||
@@ -215,11 +395,12 @@ END
     end
 
     def dependencies(filename)
-      File.readlines(filename).grep(/^@import /).map do |line|
-        line[8..-1].split(',').map do |inc|
-          Sass::Files.find_file_to_import(inc.strip, [File.dirname(filename)] + load_paths)
-        end
-      end.flatten.grep(/\.sass$/)
+      Files.tree_for(filename, engine_options).select {|n| n.is_a?(Tree::ImportNode)}.map do |n|
+        next if n.full_filename =~ /\.css$/
+        n.full_filename
+      end.compact
+    rescue Sass::SyntaxError => e
+      [] # If the file has an error, we assume it has no dependencies
     end
   end
 end