radiantcms-couchrest_model 0.1.3 → 0.1.4

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

@@ -1,11 +1,8 @@
-require 'fileutils'
-
 require 'sass'
-require 'sass/plugin/configuration'
-require 'sass/plugin/staleness_checker'
+require 'rbconfig'
 
 module Sass
-  # This module handles the compilation of Sass/SCSS files.
+  # This module handles the compilation of Sass files.
   # It provides global options and checks whether CSS files
   # need to be updated.
   #
@@ -14,23 +11,15 @@ 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
-
+    extend self
+
+    @options = {
+      :css_location       => './public/stylesheets',
+      :always_update      => false,
+      :always_check       => true,
+      :full_exception     => true
+    }
     @checked_for_updates = false
 
     # Whether or not Sass has **ever** checked if the stylesheets need to be updated
@@ -39,6 +28,30 @@ 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.
@@ -52,225 +65,164 @@ module Sass
 
     # Updates out-of-date stylesheets.
     #
-    # Checks each Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
+    # Checks each Sass 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.
-    #
-    # @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 = [])
+    def update_stylesheets
       return if options[:never_update]
 
-      run_updating_stylesheets individual_files
-
-      individual_files.each {|t, c| update_stylesheet(t, c)}
-
       @checked_for_updates = true
-      staleness_checker = StalenessChecker.new
+      template_locations.zip(css_locations).each do |template_location, css_location|
 
-      template_location_array.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")).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
+          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
+            update_stylesheet(name, template_location, css_location)
           end
         end
       end
     end
 
-    # 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
+    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
+    def update_stylesheet(name, template_location, css_location)
+      css = css_filename(name, css_location)
+      File.delete(css) if File.exists?(css)
 
-      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
+      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
 
-      # 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'
+      # Create any directories that might be necessary
+      mkpath(css_location, name)
 
-            path.update do |base, relative|
-              run_template_modified File.join(base, relative)
-              update_stylesheets(individual_files)
-            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) }
+    end
 
-            path.create do |base, relative|
-              run_template_created File.join(base, relative)
-              update_stylesheets(individual_files)
-            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 }
+      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]]
+      end
+    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
+    def exception_string(e)
+      e_string = "#{e.class}: #{e.message}"
 
-        individual_files.each do |template, css|
-          mon.file template do |path|
-            path.update do
-              run_template_modified template
-              update_stylesheets(individual_files)
-            end
+      if e.is_a? Sass::SyntaxError
+        e_string << "\non line #{e.sass_line}"
 
-            path.create do
-              run_template_created template
-              update_stylesheets(individual_files)
-            end
+        if e.sass_filename
+          e_string << " of #{e.sass_filename}"
+
+          if File.exists?(e.sass_filename)
+            e_string << "\n\n"
 
-            path.delete do
-              run_template_deleted template
-              try_delete_css css
-              update_stylesheets(individual_files)
+            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
 
-    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
+    def template_filename(name, path)
+      "#{path}/#{name}.sass"
     end
 
-    def try_delete_css(css)
-      return unless File.exists?(css)
-      run_deleting_css css
-      File.delete css
+    def css_filename(name, path)
+      "#{path}/#{name}.css"
     end
 
-    def load_paths(opts = options)
-      (opts[:load_paths] || []) + template_locations
+    def forbid_update?(name)
+      name.sub(/^.*\//, '')[0] == ?_
     end
 
-    def template_locations
-      template_location_array.to_a.map {|l| l.first}
+    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 css_locations
-      template_location_array.to_a.map {|l| l.last}
-    end
+    def exact_stylesheet_needs_update?(css_file, template_file)
+      return true unless File.exists?(css_file)
 
-    def css_filename(name, path)
-      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
+      css_mtime = File.mtime(css_file)
+      File.mtime(template_file) > css_mtime ||
+        dependencies(template_file).any?(&dependency_updated?(css_mtime))
     end
 
-    def forbid_update?(name)
-      name.sub(/^.*\//, '')[0] == ?_
+    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
     end
 
-    # Compass expects this to exist
-    def stylesheet_needs_update?(css_file, template_file)
-      StalenessChecker.stylesheet_needs_update?(css_file, template_file)
+    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$/)
     end
   end
 end
 
-if defined?(ActionController)
-  require 'sass/plugin/rails'
-elsif defined?(Merb::Plugins)
-  require 'sass/plugin/merb'
-else
-  require 'sass/plugin/generic'
-end
+require 'sass/plugin/rails' if defined?(ActionController)
+require 'sass/plugin/merb'  if defined?(Merb::Plugins)

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

@@ -14,7 +14,6 @@ unless defined?(Sass::MERB_LOADED)
                               :css_location      => root + '/public/stylesheets',
                               :cache_location    => root + '/tmp/sass-cache',
                               :always_check      => env != "production",
-                              :quiet             => env != "production",
                               :full_exception    => env != "production")
   config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
 
@@ -24,14 +23,27 @@ unless defined?(Sass::MERB_LOADED)
 
   Sass::Plugin.options.merge!(config)
 
-  require 'sass/plugin/rack'
-  class Sass::Plugin::MerbBootLoader < Merb::BootLoader
-    after Merb::BootLoader::RackUpApplication
+  if version[0] > 0 || version[1] >= 9
 
-    def self.run
-      # Apparently there's no better way than this to add Sass
-      # to Merb's Rack stack.
-      Merb::Config[:app] = Sass::Plugin::Rack.new(Merb::Config[:app])
+    class Merb::Rack::Application
+      def call_with_sass(env)
+        Sass::Plugin.check_for_updates
+        call_without_sass(env)
+      end
+      alias_method :call_without_sass, :call
+      alias_method :call, :call_with_sass
     end
+
+  else
+
+    class MerbHandler
+      def process_with_sass(request, response)
+        Sass::Plugin.check_for_updates
+        process_without_sass(request, response)
+      end
+      alias_method :process_without_sass, :process
+      alias_method :process, :process_with_sass
+    end
+
   end
 end