classiccms 0.3.0 → 0.3.1

data/vendor/bundle/gems/sass-3.1.19/lib/sass/logger/base.rb

@@ -0,0 +1,32 @@
+require 'sass/logger/log_level'
+
+class Sass::Logger::Base
+  
+  include Sass::Logger::LogLevel
+
+  attr_accessor :log_level
+  attr_accessor :disabled
+
+  log_level :trace
+  log_level :debug
+  log_level :info
+  log_level :warn
+  log_level :error
+
+  def initialize(log_level = :debug)
+    self.log_level = log_level
+  end
+
+  def logging_level?(level)
+    !disabled && self.class.log_level?(level, log_level)
+  end
+
+  def log(level, message)
+    self._log(level, message) if logging_level?(level)
+  end
+
+  def _log(level, message)
+    Kernel::warn(message)
+  end
+
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/logger/log_level.rb

@@ -0,0 +1,49 @@
+module Sass
+  module Logger
+    module LogLevel
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def inherited(subclass)
+          subclass.log_levels = subclass.superclass.log_levels.dup
+        end
+
+        def log_levels
+          @log_levels ||= {}
+        end
+
+        def log_levels=(levels)
+          @log_levels = levels
+        end
+
+        def log_level?(level, min_level)
+          log_levels[level] >= log_levels[min_level]
+        end
+
+        def log_level(name, options = {})
+          if options[:prepend]
+            level = log_levels.values.min
+            level = level.nil? ? 0 : level - 1
+          else
+            level = log_levels.values.max
+            level = level.nil? ? 0 : level + 1
+          end
+          log_levels.update(name => level)
+          define_logger(name)
+        end
+
+        def define_logger(name, options = {})
+          class_eval %Q{
+            def #{name}(message)
+              #{options.fetch(:to, :log)}(#{name.inspect}, message)
+            end
+          }
+        end
+      end
+      
+    end
+  end
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/logger.rb

@@ -0,0 +1,15 @@
+module Sass::Logger
+
+end
+
+require "sass/logger/log_level"
+require "sass/logger/base"
+
+module Sass
+
+  class << self
+    attr_accessor :logger
+  end
+
+  self.logger = Sass::Logger::Base.new
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/plugin/compiler.rb

@@ -0,0 +1,384 @@
+require 'fileutils'
+
+require 'sass'
+# XXX CE: is this still necessary now that we have the compiler class?
+require 'sass/callbacks'
+require 'sass/plugin/configuration'
+require 'sass/plugin/staleness_checker'
+
+module Sass::Plugin
+
+  # The Compiler class handles compilation of multiple files and/or directories,
+  # including checking which CSS files are out-of-date and need to be updated
+  # and calling Sass to perform the compilation on those files.
+  #
+  # {Sass::Plugin} uses this class to update stylesheets for a single application.
+  # Unlike {Sass::Plugin}, though, the Compiler class has no global state,
+  # and so multiple instances may be created and used independently.
+  #
+  # If you need to compile a Sass string into CSS,
+  # please see the {Sass::Engine} class.
+  #
+  # Unlike {Sass::Plugin}, this class doesn't keep track of
+  # whether or how many times a stylesheet should be updated.
+  # Therefore, the following `Sass::Plugin` options are ignored by the Compiler:
+  #
+  # * `:never_update`
+  # * `:always_check`
+  class Compiler
+    include Sass::Util
+    include Configuration
+    extend Sass::Callbacks
+
+    # Creates a new compiler.
+    #
+    # @param options [{Symbol => Object}]
+    #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    def initialize(options = {})
+      self.options.merge!(options)
+    end
+
+    # Register a callback to be run after stylesheets are mass-updated.
+    # This is run whenever \{#update\_stylesheets} is called,
+    # unless the \{file:SASS_REFERENCE.md#never_update-option `:never_update` option}
+    # is enabled.
+    #
+    # @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 after a single stylesheet is updated.
+    # The callback is only run if the stylesheet is really updated;
+    # if the CSS file is fresh, this won't be run.
+    #
+    # Even if the \{file:SASS_REFERENCE.md#full_exception-option `:full_exception` option}
+    # is enabled, this callback won't be run
+    # when an exception CSS file is being written.
+    # To run an action for those files, use \{#on\_compilation\_error}.
+    #
+    # @yield [template, css]
+    # @yieldparam template [String]
+    #   The location of the Sass/SCSS file being updated.
+    # @yieldparam css [String]
+    #   The location of the CSS file being generated.
+    define_callback :updated_stylesheet
+
+    # Register a callback to be run before a single stylesheet is updated.
+    # The callback is only run if the stylesheet is guaranteed to be updated;
+    # if the CSS file is fresh, this won't be run.
+    #
+    # 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
+
+    def on_updating_stylesheet_with_deprecation_warning(&block)
+      Sass::Util.sass_warn("Sass::Compiler#on_updating_stylesheet callback is deprecated and will be removed in a future release. Use Sass::Compiler#on_updated_stylesheet instead, which is run after stylesheet compilation.")
+      on_updating_stylesheet_without_deprecation_warning(&block)
+    end
+    alias_method :on_updating_stylesheet_without_deprecation_warning, :on_updating_stylesheet
+    alias_method :on_updating_stylesheet, :on_updating_stylesheet_with_deprecation_warning
+
+    # Register a callback to be run when Sass decides not to update a stylesheet.
+    # In particular, the callback is run when Sass finds that
+    # the template file and none of its dependencies
+    # 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
+
+    # Updates out-of-date stylesheets.
+    #
+    # 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.
+    #
+    # @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 = [])
+      Sass::Plugin.checked_for_updates = true
+      staleness_checker = StalenessChecker.new(engine_options)
+
+      template_location_array.each do |template_location, css_location|
+        Sass::Util.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
+          # Get the relative path to the file
+          name = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
+          css = css_filename(name, css_location)
+          individual_files << [file, css]
+        end
+      end
+
+      run_updating_stylesheets individual_files
+
+      individual_files.each do |file, css|
+        if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
+          update_stylesheet(file, css)
+        else
+          run_not_updating_stylesheet(file, css)
+        end
+      end
+    end
+
+    # 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 [Listen](http://github.com/guard/listen) library
+    # to monitor the filesystem for changes.
+    # Listen isn't loaded until `watch` is run.
+    # The version of Listen 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 'listen'
+      rescue LoadError => e
+        dir = Sass::Util.scope("vendor/listen/lib")
+        if $LOAD_PATH.include?(dir)
+          e.message << "\n" <<
+            if File.exists?(scope(".git"))
+              'Run "git submodule update --init" to get the recommended version.'
+            else
+              'Run "gem install listen" to get it.'
+            end
+          raise e
+        else
+          $LOAD_PATH.unshift dir
+          retry
+        end
+      end
+
+      template_paths = template_locations # cache the locations
+      individual_files_hash = individual_files.inject({}) do |h, files|
+        parent = File.dirname(files.first)
+        (h[parent] ||= []) << files unless template_paths.include?(parent)
+        h
+      end
+      directories = template_paths + individual_files_hash.keys +
+        [{:relative_paths => true}]
+
+      # TODO: Keep better track of what depends on what
+      # so we don't have to run a global update every time anything changes.
+      listener = Listen::MultiListener.new(*directories) do |modified, added, removed|
+        modified.each do |f|
+          parent = File.dirname(f)
+          if files = individual_files_hash[parent]
+            next unless files.first == f
+          else
+            next unless f =~ /\.s[ac]ss$/
+          end
+          run_template_modified(f)
+        end
+
+        added.each do |f|
+          parent = File.dirname(f)
+          if files = individual_files_hash[parent]
+            next unless files.first == f
+          else
+            next unless f =~ /\.s[ac]ss$/
+          end
+          run_template_created(f)
+        end
+
+        removed.each do |f|
+          parent = File.dirname(f)
+          if files = individual_files_hash[parent]
+            next unless files.first == f
+            try_delete_css files[1]
+          else
+            next unless f =~ /\.s[ac]ss$/
+            try_delete_css f.gsub(/\.s[ac]ss$/, '.css')
+          end
+          run_template_deleted(f)
+        end
+
+        update_stylesheets(individual_files)
+      end
+
+      # The native windows listener is much slower than the polling
+      # option, according to https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e#commitcomment-1295118
+      listener.force_polling(true) if Sass::Util.windows?
+
+      begin
+        listener.start
+      rescue Exception => e
+        raise e unless e.is_a?(Interrupt)
+      end
+    end
+
+    # Non-destructively modifies \{#options} so that default values are properly set,
+    # and returns the result.
+    #
+    # @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.merge(additional_options)
+      opts[:load_paths] = load_paths(opts)
+      opts
+    end
+
+    # Compass expects this to exist
+    def stylesheet_needs_update?(css_file, template_file)
+      StalenessChecker.stylesheet_needs_update?(css_file, template_file)
+    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
+        File.read(filename) unless File.readable?(filename) # triggers an error for handling
+        engine_opts = engine_options(:css_filename => css, :filename => filename)
+        result = Sass::Engine.for_file(filename, engine_opts).render
+      rescue Exception => e
+        compilation_error_occured = true
+        run_compilation_error e, filename, css
+        result = Sass::SyntaxError.exception_to_css(e, options)
+      else
+        run_updating_stylesheet filename, css
+      end
+
+      write_file(css, result)
+      run_updated_stylesheet(filename, css) unless compilation_error_occured
+    end
+
+    def write_file(css, content)
+      flag = 'w'
+      flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
+      File.open(css, flag) do |file|
+        file.set_encoding(content.encoding) unless Sass::Util.ruby1_8?
+        file.print(content)
+      end
+    end
+
+    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
+      template_location_array.to_a.map {|l| l.first}
+    end
+
+    def css_locations
+      template_location_array.to_a.map {|l| l.last}
+    end
+
+    def css_filename(name, path)
+      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
+    end
+  end
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/plugin/configuration.rb

@@ -0,0 +1,123 @@
+# We keep configuration in its own self-contained file
+# so that we can load it independently in Rails 3,
+# where the full plugin stuff is lazy-loaded.
+
+module Sass
+  module Plugin
+    module Configuration
+
+      # Returns the default options for a {Sass::Plugin::Compiler}.
+      #
+      # @return [{Symbol => Object}]
+      def default_options
+        @default_options ||= {
+          :css_location       => './public/stylesheets',
+          :always_update      => false,
+          :always_check       => true,
+          :full_exception     => true,
+          :cache_location     => ".sass-cache"
+        }.freeze
+      end
+
+      # Resets the options and {Sass::Callbacks::InstanceMethods#clear_callbacks! clears all callbacks}.
+      def reset!
+        @options = nil
+        clear_callbacks!
+      end
+
+      # An options hash.
+      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [{Symbol => Object}]
+      def options
+        @options ||= default_options.dup
+      end
+
+      # Sets the options hash.
+      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # See {Sass::Plugin::Configuration#reset!}
+      # @deprecated Instead, modify the options hash in-place.
+      # @param value [{Symbol => Object}] The options hash
+      def options=(value)
+        Sass::Util.sass_warn("Setting Sass::Plugin.options is deprecated " +
+                             "and will be removed in a future release.")
+        options.merge!(value)
+      end
+
+      # Adds a new template-location/css-location mapping.
+      # This means that Sass/SCSS files in `template_location`
+      # will be compiled to CSS files in `css_location`.
+      #
+      # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # since the option can be in multiple formats.
+      #
+      # Note that this method will change `options[:template_location]`
+      # to be in the Array format.
+      # This means that even if `options[:template_location]`
+      # had previously been a Hash or a String,
+      # it will now be an Array.
+      #
+      # @param template_location [String] The location where Sass/SCSS files will be.
+      # @param css_location [String] The location where compiled CSS files will go.
+      def add_template_location(template_location, css_location = options[:css_location])
+        normalize_template_location!
+        template_location_array << [template_location, css_location]
+      end
+
+      # Removes a template-location/css-location mapping.
+      # This means that Sass/SCSS files in `template_location`
+      # will no longer be compiled to CSS files in `css_location`.
+      #
+      # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # since the option can be in multiple formats.
+      #
+      # Note that this method will change `options[:template_location]`
+      # to be in the Array format.
+      # This means that even if `options[:template_location]`
+      # had previously been a Hash or a String,
+      # it will now be an Array.
+      #
+      # @param template_location [String]
+      #   The location where Sass/SCSS files were,
+      #   which is now going to be ignored.
+      # @param css_location [String]
+      #   The location where compiled CSS files went, but will no longer go.
+      # @return [Boolean]
+      #   Non-`nil` if the given mapping already existed and was removed,
+      #   or `nil` if nothing was changed.
+      def remove_template_location(template_location, css_location = options[:css_location])
+        normalize_template_location!
+        template_location_array.delete([template_location, css_location])
+      end
+
+      # Returns the template locations configured for Sass
+      # as an array of `[template_location, css_location]` pairs.
+      # See the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # for details.
+      #
+      # @return [Array<(String, String)>]
+      #   An array of `[template_location, css_location]` pairs.
+      def template_location_array
+        old_template_location = options[:template_location]
+        normalize_template_location!
+        options[:template_location]
+      ensure
+        options[:template_location] = old_template_location
+      end
+
+      private
+
+      def normalize_template_location!
+        return if options[:template_location].is_a?(Array)
+        options[:template_location] =
+          case options[:template_location]
+          when nil
+            options[:css_location] ?
+              [[File.join(options[:css_location], 'sass'), options[:css_location]]] : []
+          when String; [[options[:template_location], options[:css_location]]]
+          else; options[:template_location].to_a
+          end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/plugin/generic.rb

@@ -0,0 +1,15 @@
+# The reason some options are declared here rather than in sass/plugin/configuration.rb
+# is that otherwise they'd clobber the Rails-specific options.
+# Since Rails' options are lazy-loaded in Rails 3,
+# they're reverse-merged with the default options
+# so that user configuration is preserved.
+# This means that defaults that differ from Rails'
+# must be declared here.
+
+unless defined?(Sass::GENERIC_LOADED)
+  Sass::GENERIC_LOADED = true
+
+  Sass::Plugin.options.merge!(:css_location   => './public/stylesheets',
+                              :always_update  => false,
+                              :always_check   => true)
+end

data/vendor/bundle/gems/sass-3.1.19/lib/sass/plugin/merb.rb

@@ -0,0 +1,48 @@
+unless defined?(Sass::MERB_LOADED)
+  Sass::MERB_LOADED = true
+
+  module Sass::Plugin::Configuration
+    # Different default options in a m envirionment.
+    def default_options
+      @default_options ||= begin
+        version = Merb::VERSION.split('.').map { |n| n.to_i }
+        if version[0] <= 0 && version[1] < 5
+          root = MERB_ROOT
+          env  = MERB_ENV
+        else
+          root = Merb.root.to_s
+          env  = Merb.environment
+        end
+
+        {
+          :always_update      => false,
+          :template_location => root + '/public/stylesheets/sass',
+          :css_location      => root + '/public/stylesheets',
+          :cache_location    => root + '/tmp/sass-cache',
+          :always_check      => env != "production",
+          :quiet             => env != "production",
+          :full_exception    => env != "production"
+        }.freeze
+      end
+    end
+  end
+
+  config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
+
+  if defined? config.symbolize_keys!
+    config.symbolize_keys!
+  end
+
+  Sass::Plugin.options.merge!(config)
+
+  require 'sass/plugin/rack'
+  class Sass::Plugin::MerbBootLoader < Merb::BootLoader
+    after Merb::BootLoader::RackUpApplication
+
+    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])
+    end
+  end
+end