radiantcms-couchrest_model 0.1.4 → 0.1.5

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

@@ -1,57 +1,35 @@
 module Sass
-  # An exception class that keeps track of
-  # the line of the Sass template it was raised on
+  # Sass::SyntaxError encapsulates information about the exception,
+  # such as the line of the Sass template it was raised on
   # and the Sass file that was being parsed (if applicable).
-  #
-  # All Sass errors are raised as {Sass::SyntaxError}s.
+  # It also provides a handy way to rescue only exceptions raised
+  # because of a faulty template.
   class SyntaxError < StandardError
-    # The line of the Sass template on which the error occurred.
-    #
-    # @return [Fixnum]
+    # The line of the Sass template on which the exception was thrown.
     attr_accessor :sass_line
 
     # The name of the file that was being parsed when the exception was raised.
-    # This could be `nil` if no filename is available.
-    #
-    # @return [String]
+    # This will be nil unless Sass is being used as an ActionView plugin.
     attr_reader :sass_filename
 
-    # @param msg [String] The error message
-    # @param lineno [Fixnum] See \{#sass\_line}
+    # Creates a new SyntaxError.
+    # +lineno+ should be the line of the Sass template on which the error occurred.
     def initialize(msg, lineno = nil)
       @message = msg
       @sass_line = lineno
     end
 
-    # Add information about the filename and line on which the error was raised,
-    # and re-raises the exception.
-    #
-    # @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
-    end
-
     # Adds a properly formatted entry to the exception's backtrace.
-    #
-    # @param filename [String] The file in which the error occurred,
-    #   if applicable (defaults to "(sass)")
+    # +filename+ should be 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}"
     end
 
-    # @return [String] The error message
-    def to_s
+    def to_s # :nodoc:
       @message
     end
   end
-
-  # The class for Sass errors that are raised due to invalid unit conversions
-  # in SassScript.
-  class UnitConversionError < SyntaxError; end
 end

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

@@ -1,168 +1,114 @@
-require 'sass'
-require 'rbconfig'
+require 'sass/engine'
 
 module Sass
-  # This module handles the compilation of Sass files.
-  # It provides global options and checks whether CSS files
-  # need to be updated.
-  #
-  # This module is used as the primary interface with Sass
-  # when it's used as a plugin for various frameworks.
-  # 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 contains methods to aid in using Sass
+  # as a stylesheet-rendering plugin for various systems.
+  # Currently Rails/ActionController and Merb are supported out of the box.
   module Plugin
-    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
-    # (in this Ruby instance).
-    #
-    # @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
+    class << self
+      @@options = {
+        :template_location  => './public/stylesheets/sass',
+        :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 updates
+      # (in this Ruby instance).
+      def checked_for_updates
+        @@checked_for_updates
+      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
+      # Gets various options for Sass. See README.rdoc for details.
+      #--
+      # TODO: *DOCUMENT OPTIONS*
+      #++
+      def options
+        @@options
+      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.
-    #
-    # @see #update_stylesheets
-    def check_for_updates
-      return unless !Sass::Plugin.checked_for_updates ||
-          Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-      update_stylesheets
-    end
+      # Sets various options for Sass.
+      def options=(value)
+        @@options.merge!(value)
+      end
 
-    # Updates out-of-date stylesheets.
-    #
-    # 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.
-    def update_stylesheets
-      return if options[:never_update]
+      # Get the options ready to be passed to the Sass::Engine
+      def engine_options(additional_options = {})
+        opts = options.dup.merge(additional_options)
+        opts[:load_paths] = load_paths(opts)
+        opts
+      end
 
-      @checked_for_updates = true
-      template_locations.zip(css_locations).each do |template_location, css_location|
+      # Checks each stylesheet in <tt>options[:css_location]</tt>
+      # to see if it needs updating,
+      # and updates it using the corresponding template
+      # from <tt>options[:templates]</tt>
+      # if it does.
+      def update_stylesheets
+        return if options[:never_update]
 
-        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]
+        @@checked_for_updates = true
+        Dir.glob(File.join(options[:template_location], "**", "*.sass")).entries.each do |file|
 
-          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
-            update_stylesheet(name, template_location, css_location)
+          # Get the relative path to the file with no extension
+          name = file.sub(options[:template_location] + "/", "")[0...-5]
+
+          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name))
+            css = css_filename(name)
+            File.delete(css) if File.exists?(css)
+
+            filename = template_filename(name)
+            engine = Engine.new(File.read(filename), engine_options(:filename => filename))
+            result = begin
+                       engine.render
+                     rescue Exception => e
+                       exception_string(e)
+                     end
+
+            # Create any directories that might be necessary
+            dirs = [options[:css_location]]
+            name.split("/")[0...-1].each { |dir| dirs << "#{dirs[-1]}/#{dir}" }
+            dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
+
+            # Finally, write the file
+            File.open(css, 'w') do |file|
+              file.print(result)
+            end
           end
         end
       end
-    end
 
-    private
+      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) }
-    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 }
+      def load_paths(opts = options)
+        (opts[:load_paths] || []) + [options[:template_location]]
       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
 
-    def exception_string(e)
-      e_string = "#{e.class}: #{e.message}"
+      def exception_string(e)
+        if options[:full_exception]
+          e_string = "#{e.class}: #{e.message}"
 
-      if e.is_a? Sass::SyntaxError
-        e_string << "\non line #{e.sass_line}"
+          if e.is_a? Sass::SyntaxError
+            e_string << "\non line #{e.sass_line}"
 
-        if e.sass_filename
-          e_string << " of #{e.sass_filename}"
+            if e.sass_filename
+              e_string << " of #{e.sass_filename}"
 
-          if File.exists?(e.sass_filename)
-            e_string << "\n\n"
+              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"
+                min = [e.sass_line - 5, 0].max
+                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
               end
-            rescue
-              e_string << "Couldn't read sass file: #{e.sass_filename}"
             end
           end
-        end
-      end
-      <<END
+          <<END
 /*
 #{e_string}
 
@@ -173,53 +119,48 @@ body:before {
   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"
-    end
+          # Fix an emacs syntax-highlighting hiccup: '
+        else
+          "/* Internal stylesheet error */"
+        end
+      end
 
-    def forbid_update?(name)
-      name.sub(/^.*\//, '')[0] == ?_
-    end
+      def template_filename(name)
+        "#{options[:template_location]}/#{name}.sass"
+      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 css_filename(name)
+        "#{options[:css_location]}/#{name}.css"
+      end
 
-    def exact_stylesheet_needs_update?(css_file, template_file)
-      return true unless File.exists?(css_file)
+      def forbid_update?(name)
+        name.sub(/^.*\//, '')[0] == ?_
+      end
 
-      css_mtime = File.mtime(css_file)
-      File.mtime(template_file) > css_mtime ||
-        dependencies(template_file).any?(&dependency_updated?(css_mtime))
-    end
+      def stylesheet_needs_update?(name)
+        if !File.exists?(css_filename(name))
+          return true
+        else
+          css_mtime = File.mtime(css_filename(name))
+          File.mtime(template_filename(name)) > css_mtime ||
+            dependencies(template_filename(name)).any?(&dependency_updated?(css_mtime))
+        end
+      end
 
-    def dependency_updated?(css_mtime)
-      lambda do |dep|
-        begin
+      def dependency_updated?(css_mtime)
+        lambda do |dep|
           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
 
-    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$/)
+      def dependencies(filename)
+        File.readlines(filename).grep(/^@import /).map do |line|
+          line[8..-1].split(',').map do |inc|
+            Sass::Engine.find_file_to_import(inc.strip, load_paths)
+          end
+        end.flatten.grep(/\.sass$/)
+      end
     end
   end
 end

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

@@ -10,11 +10,10 @@ unless defined?(Sass::MERB_LOADED)
     env  = Merb.environment
   end
 
-  Sass::Plugin.options.merge!(:template_location => root + '/public/stylesheets/sass',
-                              :css_location      => root + '/public/stylesheets',
-                              :cache_location    => root + '/tmp/sass-cache',
-                              :always_check      => env != "production",
-                              :full_exception    => env != "production")
+  Sass::Plugin.options.merge!(:template_location  => root + '/public/stylesheets/sass',
+                              :css_location       => root + '/public/stylesheets',
+                              :always_check       => env != "production",
+                              :full_exception     => env != "production")
   config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
 
   if defined? config.symbolize_keys!
@@ -25,9 +24,13 @@ unless defined?(Sass::MERB_LOADED)
 
   if version[0] > 0 || version[1] >= 9
 
-    class Merb::Rack::Application
+    class Merb::Rack::Application # :nodoc:
       def call_with_sass(env)
-        Sass::Plugin.check_for_updates
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
         call_without_sass(env)
       end
       alias_method :call_without_sass, :call
@@ -36,9 +39,13 @@ unless defined?(Sass::MERB_LOADED)
 
   else
 
-    class MerbHandler
+    class MerbHandler # :nodoc:
       def process_with_sass(request, response)
-        Sass::Plugin.check_for_updates
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
         process_without_sass(request, response)
       end
       alias_method :process_without_sass, :process