radiant 0.9.1 → 1.0.0.rc1

data/vendor/plugins/haml/lib/sass/less.rb

@@ -0,0 +1,382 @@
+#!/usr/bin/env ruby
+
+require 'less'
+
+module Less
+  # This is the class that Treetop defines for parsing Less files.
+  # Since not everything gets parsed into the AST but is instead resolved at parse-time,
+  # we need to override some of it so that it can be converted into Sass.
+  module StyleSheet
+    # Selector mixins that don't have arguments.
+    # This depends only on the syntax at the call site;
+    # if it doesn't use parens, it hits this production,
+    # regardless of whether the mixin being called has arguments or not.
+    module Mixin4
+      def build_with_sass(env)
+        selectors.build(env, :mixin).each do |path|
+          el = path.inject(env.root) do |current, node|
+            current.descend(node.selector, node) or raise MixinNameError, "#{selectors.text_value} in #{env}"
+          end
+          if el.is_a?(Node::Mixin::Def)
+            # Calling a mixin with arguments, which gets compiled to a Sass mixin
+            env << Node::Mixin::Call.new(el, [], env)
+          else
+            # Calling a mixin without arguments, which gets compiled to @extend
+            sel = selector_str(path)
+            base = selector_str(selector_base(path))
+            if base == sel
+              env << Node::SassNode.new(Sass::Tree::ExtendNode.new([sel]))
+            else
+              Haml::Util.haml_warn <<WARNING
+WARNING: Sass doesn't support mixing in selector sequences.
+Replacing "#{sel}" with "@extend #{base}"
+WARNING
+              env << Node::SassNode.new(Sass::Tree::CommentNode.new("// #{sel};", true))
+              env << Node::SassNode.new(Sass::Tree::ExtendNode.new([base]))
+            end
+          end
+        end
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+
+      def selector_base(path)
+        el, i = Haml::Util.enum_with_index(path).to_a.reverse.find {|e, i| e.selector !~ /^:{1,2}$/} ||
+          [path.first, 0]
+        sel = (el.selector =~ /^:{0,2}$/ ? el.selector : "")
+        [Node::Element.new(el.name, sel)] + path[i+1..-1]
+      end
+
+      def selector_str(path)
+        path.map {|e| e.sass_selector_str}.join(' ').gsub(' :', ':')
+      end
+    end
+
+    # Property and variable declarations.
+    # We want to keep track of the line number
+    # so we don't space out the variables too much in the generated Sass.
+    module Declaration3
+      def build_with_sass(env)
+        build_without_sass(env)
+        env.rules.last.src_line = input.line_of(interval.first)
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+    end
+
+    # Comma-separated selectors.
+    # Less breaks these into completely separate nodes.
+    # Since we don't want this duplication in the Sass,
+    # we modify the production to keep track of the original group
+    # so we can reconstruct it later on.
+    module Selectors2
+      def build_with_sass(env, method)
+        arr = build_without_sass(env, method)
+        return arr if method == :mixin
+        rarr = arr.map {|e| e.top(env)}
+        rarr.each {|e| e.group = rarr}
+        arr
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+    end
+
+    # Attribute accessors.
+    # Sass just flat-out doesn't support these,
+    # so we print a warning to that effect and compile them to comments.
+    module Accessor1
+      def build(env)
+        Haml::Util.haml_warn <<WARNING
+WARNING: Sass doesn't support attribute accessors.
+Ignoring #{text_value}
+WARNING
+        Node::Anonymous.new("/* #{text_value} */")
+      end
+    end
+
+    # @import statements.
+    # Less handles these during parse-time,
+    # so we want to wrap them up as a node in the tree.
+    # We also include the nodes, though,
+    # since we want to have access to the mixins
+    # so we can tell if they take arguments or not.
+    # The included nodes are hidden so they don't appear in the output.
+    module Import1
+      def build_with_sass(env)
+        line = input.line_of(interval.first)
+        import = Sass::Tree::ImportNode.new(url.value.gsub(/\.less$/, ''))
+        import.line = input.line_of(interval.first)
+        env << Node::SassNode.new(import)
+        old_rules = env.rules.dup
+        build_without_sass env
+        (env.rules - old_rules).each {|r| r.hide_in_sass = true}
+      rescue ImportError => e
+        raise Sass::SyntaxError.new("File to import #{url.text_value} not found or unreadable", :line => line)
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+    end
+
+    # The IE-specific `alpha(opacity=@var)`.
+    # Less manually resolves the variable here at parse-time.
+    # We want to keep the variable around,
+    # so we compile this to a function.
+    # Less doesn't actually have an `=` operator,
+    # but that's okay since it's just getting compiled to Sass anyway.
+    module Entity::Alpha1
+      def build(env)
+        Node::Function.new("alpha",
+          [Node::Expression.new([
+                Node::Keyword.new("opacity"),
+                Node::Operator.new("="),
+                variable.build])])
+      end
+    end
+  end
+
+  # The Less AST classes for the document,
+  # including both stylesheet-level nodes and expression-level nodes.
+  # The main purpose of overriding these is to add `#to_sass_tree` functions
+  # for converting to Sass.
+  module Node
+    module Entity
+      attr_accessor :hide_in_sass
+      attr_accessor :src_line
+    end
+
+    class Element
+      attr_accessor :group
+
+      def top(env)
+        return self if parent.equal?(env)
+        return parent.top(env)
+      end
+
+      def to_sass_tree
+        if root?
+          root = Sass::Tree::RootNode.new("")
+          rules.each {|r| root << r.to_sass_tree}
+          return root
+        end
+        return if hide_in_sass
+        return if !self.equal?(group.first)
+
+        last_el = nil
+        sel = group.map do |el|
+          comma_sel = []
+          loop do
+            comma_sel << el.sass_selector_str
+            break unless el.rules.size == 1 && el.rules.first.is_a?(Element)
+            el = el.rules.first
+          end
+          last_el = el
+          comma_sel = comma_sel.join(' ').gsub(' :', ':')
+          comma_sel.gsub!(/^:/, '&:') unless parent.root?
+          comma_sel
+        end.join(', ')
+
+        rule = Sass::Tree::RuleNode.new([sel])
+        last_el.rules.each {|r| rule << r.to_sass_tree}
+        return rule
+      end
+
+      def sass_selector_str
+        case @selector
+        when /[+>~]/; "#{@selector} #{@name}"
+        else @selector + @name
+        end
+      end
+    end
+
+    module Mixin
+      class Call
+        def to_sass_tree
+          return if hide_in_sass
+          Sass::Tree::MixinNode.new(@mixin.name.gsub(/^\./, ''), @params.map {|v| v.to_sass_tree})
+        end
+      end
+
+      class Def
+        def to_sass_tree
+          return if hide_in_sass
+          mixin = Sass::Tree::MixinDefNode.new(name, @params.map do |v|
+              v.value.flatten!
+              [Sass::Script::Variable.new(v), v.value.to_sass_tree]
+            end)
+          rules.each {|r| mixin << r.to_sass_tree}
+          mixin
+        end
+      end
+    end
+
+    class SassNode
+      include Entity
+
+      def initialize(node)
+        @node = node
+      end
+
+      def to_sass_tree
+        return if hide_in_sass
+        @node
+      end
+    end
+
+    class Property
+      def to_sass_tree
+        return if hide_in_sass
+        Sass::Tree::PropNode.new([self], @value.to_sass_tree, :new)
+      end
+    end
+
+    class Expression
+      def to_sass_tree
+        if first.is_a?(Array)
+          val = map {|e| _to_sass_tree(e)}.inject(nil) do |e, i|
+            next i unless e
+            Sass::Script::Operation.new(e, i, :comma)
+          end
+        else
+          val = _to_sass_tree(self)
+        end
+        val.options = {}
+        val
+      end
+
+      private
+
+      LESS_TO_SASS_OPERATORS = {"-" => :minus, "+" => :plus, "*" => :times, "/" => :div, "=" => :single_eq}
+
+      def _to_sass_tree(arr)
+        e, rest = _to_sass_tree_plus_minus_eq(arr)
+        until rest.empty?
+          e2, rest = _to_sass_tree_plus_minus_eq(rest)
+          e = Sass::Script::Operation.new(e, e2, :concat)
+        end
+        return e
+      end
+
+      def _to_sass_tree_plus_minus_eq(arr)
+        e, rest = _to_sass_tree_times_div(arr)
+        while rest[0] && rest[0].is_a?(Operator) && %w[+ - =].include?(rest[0])
+          op = LESS_TO_SASS_OPERATORS[rest[0]]
+          e2, rest = _to_sass_tree_times_div(rest[1..-1])
+          e = Sass::Script::Operation.new(e, e2, op)
+        end
+        return e, rest
+      end
+
+      def _to_sass_tree_times_div(arr)
+        e, rest = _to_sass_tree_unary(arr)
+        while rest[0] && rest[0].is_a?(Operator) && %w[* /].include?(rest[0])
+          op = LESS_TO_SASS_OPERATORS[rest[0]]
+          e2, rest = _to_sass_tree_unary(rest[1..-1])
+          e = Sass::Script::Operation.new(e, e2, op)
+        end
+        return e, rest
+      end
+
+      def _to_sass_tree_unary(arr)
+        if arr[0] == "-"
+          first, rest = _sass_split(arr[1..-1])
+          return Sass::Script::UnaryOperation.new(first, :minus), rest
+        else
+          return _sass_split(arr[0..-1])
+        end
+      end
+
+      def _sass_split(arr)
+        return arr[0].to_sass_tree, arr[1..-1] unless arr[0] == "("
+        parens = 1
+        i = arr[1..-1].each_with_index do |e, i|
+          parens += 1 if e == "("
+          parens -= 1 if e == ")"
+          break i if parens == 0
+        end
+
+        return _to_sass_tree(arr[1...i+1]), arr[i+2..-1]
+      end
+    end
+
+    class Color
+      def to_sass_tree
+        Sass::Script::Color.new(:red => r, :green => g, :blue => b, :alpha => a)
+      end
+    end
+
+    class Number
+      def to_sass_tree
+        Sass::Script::Number.new(self, [self.unit])
+      end
+    end
+
+    class Variable
+      def to_sass_tree
+        if @declaration
+          return if hide_in_sass
+          node = Sass::Tree::VariableNode.new(self, @value.to_sass_tree, false)
+          node.line = self.src_line
+          node
+        else
+          Sass::Script::Variable.new(self)
+        end
+      end
+    end
+
+    class Function
+      def to_sass_tree
+        Sass::Script::Funcall.new(self, @args.map {|a| a.to_sass_tree})
+      end
+    end
+
+    class Keyword
+      def to_sass_tree
+        Sass::Script::String.new(self)
+      end
+    end
+
+    class Anonymous
+      def to_sass_tree
+        Sass::Script::String.new(self)
+      end
+    end
+
+    class Quoted
+      def to_sass_tree
+        Sass::Script::String.new(self, true)
+      end
+    end
+
+    class FontFamily
+      def to_sass_tree
+        @family.map {|f| f.to_sass_tree}.inject(nil) do |e, f|
+          next f unless e
+          Sass::Script::Operation.new(e, f, :comma)
+        end
+      end
+    end
+  end
+
+  # The entry point to Less.
+  # By default Less doesn't preserve the filename of the file being parsed,
+  # which is unpleasant for error reporting.
+  # Our monkeypatch keeps it around.
+  class Engine
+    def initialize_with_sass(obj, opts = {})
+      initialize_without_sass(obj, opts)
+      @filename = obj.path if obj.is_a?(File)
+    end
+    alias_method :initialize_without_sass, :initialize
+    alias_method :initialize, :initialize_with_sass
+
+    def parse_with_sass
+      parse_without_sass
+    rescue Sass::SyntaxError => e
+      e.modify_backtrace(:filename => @filename)
+      raise e
+    end
+    alias_method :parse_without_sass, :parse
+    alias_method :parse, :parse_with_sass
+    alias_method :to_tree, :parse
+  end
+end

data/vendor/plugins/haml/lib/sass/plugin.rb

@@ -1,8 +1,11 @@
+require 'fileutils'
+
 require 'sass'
-require 'rbconfig'
+require 'sass/plugin/configuration'
+require 'sass/plugin/staleness_checker'
 
 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,15 +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
-    extend self
-
-    @options = {
-      :css_location       => './public/stylesheets',
-      :always_update      => false,
-      :always_check       => true,
-      :full_exception     => true
-    }
+    include Haml::Util
+
     @checked_for_updates = false
 
     # Whether or not Sass has **ever** checked if the stylesheets need to be updated
@@ -28,30 +39,6 @@ module Sass
     # @return [Boolean]
     attr_reader :checked_for_updates
 
-    # An options hash.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    #
-    # @return [{Symbol => Object}]
-    attr_reader :options
-
-    # Sets the options hash.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    #
-    # @param value [{Symbol => Object}] The options hash
-    def options=(value)
-      @options.merge!(value)
-    end
-
-    # Non-destructively modifies \{#options} so that default values are properly set.
-    #
-    # @param additional_options [{Symbol => Object}] An options hash with which to merge \{#options}
-    # @return [{Symbol => Object}] The modified options hash
-    def engine_options(additional_options = {})
-      opts = options.dup.merge(additional_options)
-      opts[:load_paths] = load_paths(opts)
-      opts
-    end
-
     # Same as \{#update\_stylesheets}, but respects \{#checked\_for\_updates}
     # and the {file:SASS_REFERENCE.md#always_update-option `:always_update`}
     # and {file:SASS_REFERENCE.md#always_check-option `:always_check`} options.
@@ -65,164 +52,225 @@ 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|
+      staleness_checker = StalenessChecker.new
 
-        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]
+      template_location_array.each do |template_location, css_location|
 
-          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
-            update_stylesheet(name, 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.sub(/\/*$/, '/'), "")
+          css = css_filename(name, css_location)
+
+          next if forbid_update?(name)
+          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
     end
 
-    private
-
-    def update_stylesheet(name, template_location, css_location)
-      css = css_filename(name, css_location)
-      File.delete(css) if File.exists?(css)
-
-      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
-
-      # Create any directories that might be necessary
-      mkpath(css_location, name)
-
-      # 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) }
+    # Updates all stylesheets, even those that aren't out-of-date.
+    # Ignores the cache.
+    #
+    # @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.
+    # @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
     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)
-        [location]
-      else
-        location.to_a.map { |l| l.first }
+    # 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
-    end
-    
-    def css_locations
-      if options[:template_location] && !options[:template_location].is_a?(String)
-        options[:template_location].to_a.map { |l| l.last }
-      else
-        [options[:css_location]]
+
+      unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"
+        # As of FSSM 0.1.4, it doesn't support FSevents on individual files,
+        # but it also isn't smart enough to switch to polling itself.
+        require 'fssm/backends/polling'
+        Haml::Util.silence_warnings do
+          FSSM::Backends.const_set(:Default, FSSM::Backends::Polling)
+        end
       end
-    end
 
-    def exception_string(e)
-      e_string = "#{e.class}: #{e.message}"
+      # 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_location_array.each do |template_location, css_location|
+          mon.path template_location do |path|
+            path.glob '**/*.s[ac]ss'
 
-      if e.is_a? Sass::SyntaxError
-        e_string << "\non line #{e.sass_line}"
+            path.update do |base, relative|
+              run_template_modified File.join(base, relative)
+              update_stylesheets(individual_files)
+            end
 
-        if e.sass_filename
-          e_string << " of #{e.sass_filename}"
+            path.create do |base, relative|
+              run_template_created File.join(base, relative)
+              update_stylesheets(individual_files)
+            end
 
-          if File.exists?(e.sass_filename)
-            e_string << "\n\n"
+            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
 
-            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}"
+        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
-/*
-#{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"
+    private
+
+    def update_stylesheet(filename, css)
+      dir = File.dirname(css)
+      unless File.exists?(dir)
+        run_creating_directory dir
+        FileUtils.mkdir_p dir
+      end
+
+      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 Haml::Util.windows? && options[:unix_newlines]
+      File.open(css, flag) do |file|
+        file.set_encoding(result.encoding) unless Haml::Util.ruby1_8?
+        file.print(result)
+      end
     end
 
-    def css_filename(name, path)
-      "#{path}/#{name}.css"
+    def try_delete_css(css)
+      return unless File.exists?(css)
+      run_deleting_css css
+      File.delete css
     end
 
-    def forbid_update?(name)
-      name.sub(/^.*\//, '')[0] == ?_
+    def load_paths(opts = options)
+      (opts[:load_paths] || []) + template_locations
     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)
+    def template_locations
+      template_location_array.to_a.map {|l| l.first}
     end
 
-    def exact_stylesheet_needs_update?(css_file, template_file)
-      return true unless File.exists?(css_file)
+    def css_locations
+      template_location_array.to_a.map {|l| l.last}
+    end
 
-      css_mtime = File.mtime(css_file)
-      File.mtime(template_file) > css_mtime ||
-        dependencies(template_file).any?(&dependency_updated?(css_mtime))
+    def css_filename(name, path)
+      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
     end
 
-    def dependency_updated?(css_mtime)
-      lambda do |dep|
-        begin
-          File.mtime(dep) > css_mtime ||
-            dependencies(dep).any?(&dependency_updated?(css_mtime))
-        rescue Sass::SyntaxError
-          # If there's an error finding depenencies, default to recompiling.
-          true
-        end
-      end
+    def forbid_update?(name)
+      name.sub(/^.*\//, '')[0] == ?_
     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$/)
+    # Compass expects this to exist
+    def stylesheet_needs_update?(css_file, template_file)
+      StalenessChecker.stylesheet_needs_update?(css_file, template_file)
     end
   end
 end
 
-require 'sass/plugin/rails' if defined?(ActionController)
-require 'sass/plugin/merb'  if defined?(Merb::Plugins)
+if defined?(ActionController)
+  require 'sass/plugin/rails'
+elsif defined?(Merb::Plugins)
+  require 'sass/plugin/merb'
+else
+  require 'sass/plugin/generic'
+end