spree 0.8.0 → 0.8.1

data/vendor/gems/haml-2.1.0/lib/haml/shared.rb

@@ -1,45 +0,0 @@
-require 'strscan'
-
-# :stopdoc:
-module Haml
-  # This module contains functionality that's shared across Haml and Sass.
-  module Shared
-    def self.handle_interpolation(str)
-      scan = StringScanner.new(str)
-      yield scan while scan.scan(/(.*?)(\\*)\#\{/)
-      scan.rest
-    end
-
-    def self.balance(scanner, start, finish, count = 0)
-      str = ''
-      scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
-      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
-      while scanner.scan(regexp)
-        str << scanner.matched
-        count += 1 if scanner.matched[-1] == start
-        count -= 1 if scanner.matched[-1] == finish
-        return [str.strip, scanner.rest] if count == 0
-      end
-    end
-
-    def self.human_indentation(indentation, was = false)
-      if !indentation.include?(?\t)
-        noun = 'space'
-      elsif !indentation.include?(?\s)
-        noun = 'tab'
-      else
-        return indentation.inspect + (was ? ' was' : '')
-      end
-
-      singular = indentation.length == 1
-      if was
-        was = singular ? ' was' : ' were'
-      else
-        was = ''
-      end
-
-      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
-    end
-  end
-end
-# :startdoc:

data/vendor/gems/haml-2.1.0/lib/haml/template.rb

@@ -1,51 +0,0 @@
-require 'haml/engine'
-
-module Haml
-  class Template
-    class << self
-      @@options = {}
-
-      # Gets various options for Haml. See README.rdoc for details.
-      def options
-        @@options
-      end
-
-      # Sets various options for Haml. See README.rdoc for details.
-      def options=(value)
-        @@options = value
-      end
-    end
-  end
-end
-
-# Decide how we want to load Haml into Rails.
-# Patching was necessary for versions <= 2.0.1,
-# but we can make it a normal handler for higher versions.
-if defined?(ActionView::TemplateHandler)
-  require 'haml/template/plugin'
-else
-  require 'haml/template/patch'
-end
-
-if defined?(RAILS_ROOT)
-  # Update init.rb to the current version
-  # if it's out of date.
-  #
-  # We can probably remove this as of v1.9,
-  # because the new init file is sufficiently flexible
-  # to not need updating.
-  rails_init_file = File.join(RAILS_ROOT, 'vendor', 'plugins', 'haml', 'init.rb')
-  haml_init_file = Haml.scope('init.rb')
-  begin
-    if File.exists?(rails_init_file)
-      require 'fileutils'
-      FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
-    end
-  rescue SystemCallError
-    warn <<END
-HAML WARNING:
-#{rails_init_file} is out of date and couldn't be automatically updated.
-Please run `haml --rails #{File.expand_path(RAILS_ROOT)}' to update it.
-END
-  end
-end

data/vendor/gems/haml-2.1.0/lib/haml/template/patch.rb

@@ -1,58 +0,0 @@
-# This file makes Haml work with Rails
-# by monkeypatching the core template-compilation methods.
-# This is necessary for versions <= 2.0.1 because the template handler API
-# wasn't sufficiently powerful to deal with caching and so forth.
-
-# This module refers to the ActionView module that's part of Ruby on Rails.
-# Haml can be used as an alternate templating engine for it,
-# and includes several modifications to make it more Haml-friendly.
-# The documentation can be found
-# here[http://rubyonrails.org/api/classes/ActionView/Base.html].
-module ActionView
-  class Base # :nodoc:
-    def delegate_template_exists_with_haml(template_path)
-      template_exists?(template_path, :haml) && [:haml]
-    end
-    alias_method :delegate_template_exists_without_haml, :delegate_template_exists?
-    alias_method :delegate_template_exists?, :delegate_template_exists_with_haml
-
-    def compile_template_with_haml(extension, template, file_name, local_assigns)
-      return compile_haml(template, file_name, local_assigns) if extension.to_s == "haml"
-      compile_template_without_haml(extension, template, file_name, local_assigns)
-    end
-    alias_method :compile_template_without_haml, :compile_template
-    alias_method :compile_template, :compile_template_with_haml
-
-    def compile_haml(template, file_name, local_assigns)
-      render_symbol = assign_method_name(:haml, template, file_name)
-      locals = local_assigns.keys
-
-      @@template_args[render_symbol] ||= {}
-      locals_keys = @@template_args[render_symbol].keys | locals
-      @@template_args[render_symbol] = Haml::Util.to_hash(locals_keys.map {|k| [k, true]})
-
-      options = Haml::Template.options.dup
-      options[:filename] = file_name || 'compiled-template'
-
-      begin
-        Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals_keys)
-      rescue Exception => e
-        if logger
-          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
-          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-        end
-
-        base_path = if defined?(extract_base_path_from)
-                      # Rails 2.0.x
-                      extract_base_path_from(file_name) || view_paths.first
-                    else
-                      # Rails <=1.2.6
-                      @base_path
-                    end
-        raise ActionView::TemplateError.new(base_path, file_name || template, @assigns, template, e)
-      end
-
-      @@compile_time[render_symbol] = Time.now
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/haml/template/plugin.rb

@@ -1,72 +0,0 @@
-# :stopdoc:
-# This file makes Haml work with Rails
-# using the > 2.0.1 template handler API.
-
-module Haml
-  class Plugin < ActionView::TemplateHandler
-    include ActionView::TemplateHandlers::Compilable if defined?(ActionView::TemplateHandlers::Compilable)
-
-    def compile(template)
-      options = Haml::Template.options.dup
-
-      # template is a template object in Rails >=2.1.0,
-      # a source string previously
-      if template.respond_to? :source
-        options[:filename] = template.filename
-        source = template.source
-      else
-        source = template
-      end
-
-      Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
-    end
-
-    def cache_fragment(block, name = {}, options = nil)
-      @view.fragment_for(block, name, options) do
-        eval("_hamlout.buffer", block.binding)
-      end
-    end
-  end
-end
-
-if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
-  ActionView::Template
-else
-  ActionView::Base
-end.register_template_handler(:haml, Haml::Plugin)
-
-# In Rails 2.0.2, ActionView::TemplateError took arguments
-# that we can't fill in from the Haml::Plugin context.
-# Thus, we've got to monkeypatch ActionView::Base to catch the error.
-if ActionView::TemplateError.instance_method(:initialize).arity == 5
-  class ActionView::Base
-    def compile_template(handler, template, file_name, local_assigns)
-      render_symbol = assign_method_name(handler, template, file_name)
-
-      # Move begin up two lines so it captures compilation exceptions.
-      begin
-        render_source = create_template_source(handler, template, render_symbol, local_assigns.keys)
-        line_offset = @@template_args[render_symbol].size + handler.line_offset
-      
-        file_name = 'compiled-template' if file_name.blank?
-        CompiledTemplates.module_eval(render_source, file_name, -line_offset)
-      rescue Exception => e # errors from template code
-        if logger
-          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
-          logger.debug "Function body: #{render_source}"
-          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-        end
-
-        # There's no way to tell Haml about the filename,
-        # so we've got to insert it ourselves.
-        e.backtrace[0].gsub!('(haml)', file_name) if e.is_a?(Haml::Error)
-        
-        raise ActionView::TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e)
-      end
-      
-      @@compile_time[render_symbol] = Time.now
-      # logger.debug "Compiled template #{file_name || template}\n ==> #{render_symbol}" if logger
-    end
-  end
-end
-# :startdoc:

data/vendor/gems/haml-2.1.0/lib/haml/util.rb

@@ -1,77 +0,0 @@
-require 'erb'
-require 'set'
-require 'enumerator'
-
-module Haml
-  module Util
-    class << self; include Haml::Util; end
-
-    RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
-
-    def to_hash(arr)
-      arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
-    end
-
-    def map_keys(hash)
-      to_hash(hash.map {|k, v| [yield(k), v]})
-    end
-
-    def map_vals(hash)
-      to_hash(hash.map {|k, v| [k, yield(v)]})
-    end
-
-    def map_hash(hash, &block)
-      to_hash(hash.map(&block))
-    end
-
-    def powerset(arr)
-      arr.inject([Set.new].to_set) do |powerset, el|
-        new_powerset = Set.new
-        powerset.each do |subset|
-          new_powerset << subset
-          new_powerset << subset + [el]
-        end
-        new_powerset
-      end
-    end
-
-    def ruby1_8?
-      Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
-    end
-
-    def has?(attr, klass, method)
-      klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
-    end
-
-    def enum_with_index(enum)
-      ruby1_8? ? enum.enum_with_index : enum.each_with_index
-    end
-
-    class StaticConditionalContext
-      def initialize(set)
-        @set = set
-      end
-
-      def method_missing(name, *args, &block)
-        super unless args.empty? && block.nil?
-        @set.include?(name)
-      end
-    end
-
-    def def_static_method(klass, name, args, *vars)
-      erb = vars.pop
-      powerset(vars).each do |set|
-        context = StaticConditionalContext.new(set).instance_eval {binding}
-        klass.class_eval(<<METHOD)
-def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
-  #{ERB.new(erb).result(context)}
-end
-METHOD
-      end
-    end
-
-    def static_method_name(name, *vars)
-      "#{name}_#{vars.map {|v| !!v}.join('_')}"
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/haml/version.rb

@@ -1,47 +0,0 @@
-module Haml
-  module Version
-    # Returns a hash representing the version of Haml.
-    # The :major, :minor, and :teeny keys have their respective numbers.
-    # The :string key contains a human-readable string representation of the version.
-    # If Haml is checked out from Git,
-    # the :rev key will have the revision hash.
-    def version
-      return @@version if defined?(@@version)
-
-      numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
-      @@version = {
-        :major => numbers[0],
-        :minor => numbers[1],
-        :teeny => numbers[2]
-      }
-      @@version[:string] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
-
-      if File.exists?(scope('REVISION'))
-        rev = File.read(scope('REVISION')).strip
-        rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
-      end
-
-      if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
-        rev = File.read(scope('.git/HEAD')).strip
-        if rev =~ /^ref: (.*)$/
-          rev = File.read(scope(".git/#{$1}")).strip
-        end
-      end
-
-      if rev
-        @@version[:rev] = rev
-        unless rev[0] == ?(
-          @@version[:string] << "."
-          @@version[:string] << rev[0...7]
-        end
-      end
-
-      @@version
-    end
-
-    # Returns the path of file relative to the Haml root.
-    def scope(file) # :nodoc:
-      File.expand_path File.join(File.dirname(__FILE__), '..', '..', file)
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass.rb

@@ -1,1062 +0,0 @@
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
-require 'haml/version'
-
-# = Sass (Syntactically Awesome StyleSheets)
-#
-# Sass is a meta-language on top of CSS
-# that's used to describe the style of a document
-# cleanly and structurally,
-# with more power than flat CSS allows.
-# Sass both provides a simpler, more elegant syntax for CSS
-# and implements various features that are useful
-# for creating manageable stylesheets.
-#
-# == Features
-#
-# * Whitespace active
-# * Well-formatted output
-# * Elegant input
-# * Feature-rich
-#
-# == Using Sass
-#
-# Sass can be used in three ways:
-# as a plugin for Ruby on Rails,
-# as a standalone Ruby module,
-# and as a command-line tool.
-# Sass is bundled with Haml,
-# so if the Haml plugin or RubyGem is installed,
-# Sass will already be installed as a plugin or gem, respectively.
-# The first step for all of these is to install the Haml gem:
-#
-#   gem install haml
-#
-# To enable it as a Rails plugin,
-# then run
-#
-#   haml --rails path/to/rails/app
-#
-# To enable Sass in Merb,
-# add
-#
-#   dependency "merb-haml"
-#
-# to config/dependencies.rb.
-#
-# Sass templates in Rails don't quite function in the same way as views,
-# because they don't contain dynamic content,
-# and so only need to be compiled when the template file has been updated.
-# By default (see options, below),
-# ".sass" files are placed in public/stylesheets/sass.
-# Then, whenever necessary, they're compiled into corresponding CSS files in public/stylesheets.
-# For instance, public/stylesheets/sass/main.sass would be compiled to public/stylesheets/main.css.
-#
-# To run Sass from the command line, just use
-#
-#   sass input.sass output.css
-#
-# Use <tt>sass --help</tt> for full documentation.
-# 
-# Using Sass in Ruby code is very simple.
-# After installing the Haml gem,
-# you can use it by running <tt>require "sass"</tt>
-# and using Sass::Engine like so:
-#
-#   engine = Sass::Engine.new("#main\n  :background-color #0000ff")
-#   engine.render #=> "#main { background-color: #0000ff; }\n"
-#
-# == CSS Rules
-#
-# Rules in flat CSS have two elements:
-# the selector
-# (e.g. "#main", "div p", "li a:hover")
-# and the attributes
-# (e.g. "color: #00ff00;", "width: 5em;").
-#
-# Sass has both of these,
-# as well as one additional element: nested rules.
-#
-# === Rules and Selectors
-#
-# However, some of the syntax is a little different.
-# The syntax for selectors is the same,
-# but instead of using brackets to delineate the attributes that belong to a particular rule,
-# Sass uses indentation.
-# For example:
-#
-#   #main p
-#     <attribute>
-#     <attribute>
-#     ...
-#
-# Like CSS, you can stretch rules over multiple lines.
-# However, unlike CSS, you can only do this if each line but the last
-# ends with a comma.
-# For example:
-#
-#   .users #userTab,
-#   .posts #postsTab
-#     <attributes>
-#
-# === Attributes
-#
-# There are two different ways to write CSS attrbibutes.
-# The first is very similar to the how you're used to writing them:
-# with a colon between the name and the value.
-# However, Sass attributes don't have semicolons at the end;
-# each attribute is on its own line, so they aren't necessary.
-# For example:
-#
-#   #main p
-#     color: #00ff00
-#     width: 97%
-#
-# is compiled to:
-#
-#   #main p {
-#     color: #00ff00;
-#     width: 97% }
-#
-# The second syntax for attributes is slightly different.
-# The colon is at the beginning of the attribute,
-# rather than between the name and the value,
-# so it's easier to tell what elements are attributes just by glancing at them.
-# For example:
-#
-#   #main p
-#     :color #00ff00
-#     :width 97%
-#
-# is compiled to:
-#
-#   #main p {
-#     color: #00ff00;
-#     width: 97% }
-#
-# By default, either attribute syntax may be used.
-# If you want to force one or the other,
-# see the <tt>:attribute_syntax</tt> option below.
-#
-# === Nested Rules
-#
-# Rules can also be nested within each other.
-# This signifies that the inner rule's selector is a child of the outer selector.
-# For example:
-#
-#   #main p
-#     :color #00ff00
-#     :width 97%
-#
-#     .redbox
-#       :background-color #ff0000
-#       :color #000000
-#
-# is compiled to:
-#
-#   #main p {
-#     color: #00ff00;
-#     width: 97%; }
-#     #main p .redbox {
-#       background-color: #ff0000;
-#       color: #000000; }
-#
-# This makes insanely complicated CSS layouts with lots of nested selectors very simple:
-#
-#   #main
-#     :width 97%
-#
-#     p, div
-#       :font-size 2em
-#       a
-#         :font-weight bold
-#
-#     pre
-#       :font-size 3em
-#
-# is compiled to:
-#
-#   #main {
-#     width: 97%; }
-#     #main p, #main div {
-#       font-size: 2em; }
-#       #main p a, #main div a {
-#         font-weight: bold; }
-#     #main pre {
-#       font-size: 3em; }
-#
-# === Referencing Parent Rules
-#
-# In addition to the default behavior of inserting the parent selector
-# as a CSS parent of the current selector
-# (e.g. above, "#main" is the parent of "p"),
-# you can have more fine-grained control over what's done with the parent selector
-# by using the ampersand character "&" in your selectors.
-#
-# The ampersand is automatically replaced by the parent selector,
-# instead of having it prepended.
-# This allows you to cleanly create pseudo-attributes:
-#
-#   a
-#     :font-weight bold
-#     :text-decoration none
-#     &:hover
-#       :text-decoration underline
-#     &:visited
-#       :font-weight normal
-#
-# Which would become:
-#
-#   a {
-#     font-weight: bold;
-#     text-decoration: none; }
-#     a:hover {
-#       text-decoration: underline; }
-#     a:visited {
-#       font-weight: normal; }
-#
-# It also allows you to add selectors at the base of the hierarchy,
-# which can be useuful for targeting certain styles to certain browsers:
-#
-#   #main
-#     :width 90%
-#     #sidebar
-#       :float left
-#       :margin-left 20%
-#       .ie6 &
-#         :margin-left 40%
-#
-# Which would become:
-#
-#   #main {
-#     width: 90%; }
-#     #main #sidebar {
-#       float: left;
-#       margin-left: 20%; }
-#       .ie6 #main #sidebar {
-#         margin-left: 40%; }
-#
-# === Attribute Namespaces
-#
-# CSS has quite a few attributes that are in "namespaces;"
-# for instance, "font-family," "font-size," and "font-weight"
-# are all in the "font" namespace.
-# In CSS, if you want to set a bunch of attributes in the same namespace,
-# you have to type it out each time.
-# Sass offers a shortcut for this:
-# just write the namespace one,
-# then indent each of the sub-attributes within it.
-# For example:
-#
-#   .funky
-#     :font
-#       :family fantasy
-#       :size 30em
-#       :weight bold
-#
-# is compiled to:
-#
-#   .funky {
-#     font-family: fantasy;
-#     font-size: 30em;
-#     font-weight: bold; }
-#
-# === Rule Escaping
-#
-# In case, for whatever reason, you need to write a rule
-# that begins with a Sass-meaningful character,
-# you can escape it with a backslash (<tt>\</tt>).
-# For example:
-#
-#  #main
-#    \+div
-#      clear: both
-#
-# is compiled to:
-#
-#  #main +div {
-#    clear: both; }
-#
-# == Directives
-#
-# Directives allow the author to directly issue instructions to the Sass compiler.
-# They're prefixed with an at sign, "<tt>@</tt>",
-# followed by the name of the directive,
-# a space, and any arguments to it -
-# just like CSS directives.
-# For example:
-#
-#   @import red.sass
-#
-# Some directives can also control whether or how many times
-# a chunk of Sass is output.
-# Those are documented under Control Structures.
-#
-# === import
-#
-# The "@import" directive works in a very similar way to the CSS import directive,
-# and sometimes compiles to a literal CSS "@import".
-#
-# Sass can import either other Sass files or plain CSS files.
-# If it imports a Sass file,
-# not only are the rules from that file included,
-# but all variables in that file are made available in the current file.
-#
-# Sass looks for other Sass files in the working directory,
-# and the Sass file directory under Rails or Merb.
-# Additional search directories may be specified
-# using the :load_paths option (see below).
-#
-# Sass can also import plain CSS files.
-# In this case, it doesn't literally include the content of the files;
-# rather, it uses the built-in CSS "@import" directive to tell the client program
-# to import the files.
-#
-# The import directive can take either a full filename
-# or a filename without an extension.
-# If an extension isn't provided,
-# Sass will try to find a Sass file with the given basename in the load paths,
-# and, failing that, will assume a relevant CSS file will be available.
-#
-# For example,
-#
-#   @import foo.sass
-#
-# would compile to
-#
-#   .foo
-#     :color #f00
-#
-# whereas
-#
-#   @import foo.css
-#
-# would compile to
-#
-#   @import foo.css
-#
-# Finally,
-#
-#   @import foo
-#
-# might compile to either,
-# depending on whether a file called "foo.sass" existed.
-#
-# === @debug
-#
-# The "@debug" directive prints the value of a SassScript expression
-# to standard error.
-# It's useful for debugging Sass files
-# that have complicated SassScript going on.
-# For example:
-#
-#   @debug 10em + 12em
-#
-# outputs:
-#
-#   Line 1 DEBUG: 22em
-#
-# === @font-face, @media, etc.
-#
-# Sass behaves as you'd expect for normal CSS @-directives.
-# For example:
-#
-#   @font-face
-#     font-family: "Bitstream Vera Sans"
-#     src: url(http://foo.bar/bvs")
-#
-# compiles to:
-#
-#   @font-face {
-#     font-family: "Bitstream Vera Sans";
-#     src: url(http://foo.bar/bvs"); }
-#
-# and
-#
-#   @media print
-#     #sidebar
-#       display: none
-#
-#     #main
-#       background-color: white
-#
-# compiles to:
-#
-#   @media print {
-#     #sidebar {
-#       display: none; }
-#
-#     #main {
-#       background-color: white; }
-#   }
-#
-# == SassScript
-#
-# In addition to the declarative templating system,
-# Sass supports a simple language known as SassScript
-# for dynamically computing CSS values and controlling
-# the styles and selectors that get emitted.
-#
-# === Interactive Shell
-#
-# You can easily experiment with SassScript using the interactive shell.
-# To launch the shell run the sass command-line with the -i option. At the
-# prompt, enter any legal SassScript expression to have it evaluated
-# and the result printed out for you:
-#
-#   $ sass -i
-#   >> "Hello, Sassy World!"
-#   "Hello, Sassy World!"
-#   >> 1px + 1px + 1px
-#   3px
-#   >> #777 + #777
-#   #eeeeee
-#   >> #777 + #888
-#   white
-#
-# === Variables
-#
-# The most straightforward way to use SassScript
-# is to set and reference variables.
-# Variables begin with exclamation marks,
-# and are set like so:
-#
-#   !width = 5em
-#
-# You can then refer to them by putting an equals sign
-# after your attributes:
-#
-#   #main
-#     :width = !width
-#
-# Variables that are first defined in a scoped context are only
-# available in that context.
-#
-# === Data Types
-#
-# SassScript supports four data types:
-# * numbers (e.g. <tt>1.2</tt>, <tt>13</tt>, <tt>10px</tt>)
-# * strings of text (e.g. <tt>"foo"</tt>, <tt>"bar"</tt>)
-# * colors (e.g. +blue+, <tt>##04a3f9</tt>)
-# * booleans (e.g. +true+, +false+)
-#
-# Any text that doesn't fit into one of those types
-# in a SassScript context will cause an error:
-#
-#   p
-#     !width = 5em
-#     // This will cause an error
-#       :border = !width solid blue
-#     // Use one of the following forms instead:
-#     :border = "#{!width} solid blue"
-#     :border = !width "solid" "blue"
-#
-# is compiled to:
-#
-#   p {
-#     border: 5em solid blue;
-#     border: 5em solid blue; }
-#
-#
-# === Operations
-#
-# SassScript supports the standard arithmetic operations on numbers
-# (<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, <tt>/</tt>, <tt>%</tt>),
-# and will automatically convert between units if it can:
-#
-#   p
-#     :width = 1in + 8pt
-#
-# is compiled to:
-#
-#   p {
-#     width: 1.111in; }
-#
-# Relational operators
-# (<tt><</tt>, <tt>></tt>, <tt><=</tt>, <tt>>=</tt>)
-# are also supported for numbers,
-# and equality operators
-# (<tt>==</tt>, <tt>!=</tt>)
-# are supported for all types.
-#
-# Most arithmetic operations are supported for color values,
-# where they work piecewise:
-#
-#   p
-#     :color = #010203 + #040506
-#
-# is compiled to:
-#
-#   p {
-#     color: #050709; }
-#
-# Some arithmetic operations even work between numbers and colors:
-#
-#   p
-#     :color = #010203 * 2
-#
-# is compiled to:
-#
-#   p {
-#     color: #020406; }
-#
-# The <tt>+</tt> operation can be used to concatenate strings:
-#
-#   p
-#     :cursor = "e" + "-resize"
-#
-# is compiled to:
-#
-#   p {
-#     cursor: e-resize; }
-#
-# Within a string of text, #{} style interpolation can be used to
-# place dynamic values within the string:
-#
-#   p
-#     :border = "#{5px + 10pt} solid #ccc"
-#
-# Finally, SassScript supports +and+, +or+, and +not+ operators
-# for boolean values.
-#
-# === Parentheses
-#
-# Parentheses can be used to affect the order of operations:
-#
-#   p
-#     :width = 1em + (2em * 3)
-#
-# is compiled to:
-#
-#   p {
-#     width: 7em; }
-#
-# === Functions
-#
-# SassScript defines some useful functions
-# that are called using the normal CSS function syntax:
-#
-#   p
-#     :color = hsl(0, 100%, 50%)
-#
-# is compiled to:
-#
-#   #main {
-#     color: #ff0000; }
-#
-# The following functions are provided: +hsl+, +percentage+, +round+, +ceil+, +floor+, and +abs+.
-# You can define additional functions in ruby.
-#
-# See Sass::Script::Functions for more information.
-#
-# === Interpolation
-#
-# You can also use SassScript variables in selectors
-# and attribute names using #{} interpolation syntax:
-#
-#   !name = foo
-#   !attr = border
-#   p.#{!name}
-#     #{attr}-color: blue
-#
-# is compiled to:
-#
-#   p.foo {
-#     border-color: blue; }
-#
-# === Optional Assignment
-#
-# You can assign to variables if they aren't already assigned
-# using the ||= assignment operator. This means that if the
-# variable has already been assigned to, it won't be re-assigned,
-# but if it doesn't have a value yet, it will be given one.
-#
-# For example:
-#
-#   !content = "First content"
-#   !content ||= "Second content?"
-#   !new_content ||= "First time reference"
-#
-#   #main
-#     content = !content
-#     new-content = !new_content
-#
-# is compiled to:
-#
-#   #main {
-#     content: First content;
-#     new-content: First time reference; }
-#
-# == Control Structures
-#
-# SassScript supports basic control structures for looping and conditionals
-# using the same syntax as directives.
-#
-# === if
-#
-# The "@if" statement takes a SassScript expression
-# and prints the code nested beneath it if the expression returns
-# anything other than +false+:
-#
-#   p
-#     @if 1 + 1 == 2
-#       :border 1px solid
-#     @if 5 < 3
-#       :border 2px dotted
-#
-# is compiled to:
-#
-#   p {
-#     border: 1px solid; }
-#
-# The "@if" statement can be followed by several "@else if" statements
-# and one "@else" statement.
-# If the "@if" statement fails,
-# the "@else if" statements are tried in order
-# until one succeeds or the "@else" is reached.
-# For example:
-#
-#   !type = "monster"
-#   p
-#     @if !type == "ocean"
-#       :color blue
-#     @else if !type == "matador"
-#       :color red
-#     @else if !type == "monster"
-#       :color green
-#     @else
-#       :color black
-#
-# is compiled to:
-#
-#   p {
-#     color: green; }
-#
-# === for
-#
-# The "@for" statement has two forms:
-# "@for <var> from <start> to <end>" or
-# "@for <var> from <start> through <end>".
-# <var> is a variable name, like <tt>!i</tt>,
-# and <start> and <end> are SassScript expressions
-# that should return integers.
-#
-# The "@for" statement sets <var> to each number
-# from <start> to <end>,
-# including <end> if "through" is used.
-# For example:
-#
-#   @for !i from 1 through 3
-#     .item-#{!i}
-#       :width = 2em * !i
-#
-# is compiled to:
-#
-#   .item-1 {
-#     width: 2em; }
-#   .item-2 {
-#     width: 4em; }
-#   .item-3 {
-#     width: 6em; }
-#
-# === while
-#
-# The "@while" statement repeatedly loops over the nested
-# block until the statement evaluates to false. This can
-# be used to achieve more complex looping than the @for
-# statement is capable of.
-# For example:
-#   !i = 6
-#   @while !i > 0
-#     .item-#{!i}
-#       :width = 2em * !i
-#     !i = !i - 2
-#
-# is compiled to:
-#
-#   .item-6 {
-#     width: 12em; }
-#
-#   .item-4 {
-#     width: 8em; }
-#
-#   .item-2 {
-#     width: 4em; }
-#
-# == Mixins
-#
-# Mixins enable you to define groups of CSS attributes and
-# then include them inline in any number of selectors
-# throughout the document. This allows you to keep your
-# stylesheets DRY and also avoid placing presentation
-# classes in your markup.
-#
-# === Defining a Mixin
-#
-# To define a mixin you use a slightly modified form of selector syntax.
-# For example the 'large-text' mixin is defined as follows:
-#
-#   =large-text
-#     :font
-#       :family Arial
-#       :size 20px
-#       :weight bold
-#     :color #ff0000
-#
-# The initial '=' marks this as a mixin rather than a standard selector.
-# The CSS rules that follow won't be included until the mixin is referenced later on.
-# Anything you can put into a standard selector,
-# you can put into a mixin definition. e.g.
-#
-#   =clearfix
-#     display: inline-block
-#     &:after
-#       content: "."
-#       display: block
-#       height: 0
-#       clear: both
-#       visibility: hidden
-#     * html &
-#       height: 1px
-#
-#
-# === Mixing it in
-#
-# Inlining a defined mixin is simple,
-# just prepend a '+' symbol to the name of a mixin defined earlier in the document.
-# So to inline the 'large-text' defined earlier,
-# we include the statment '+large-text' in our selector definition thus:
-#
-#   .page-title
-#     +large-text
-#     :padding 4px
-#     :margin
-#       :top 10px
-#
-#
-# This will produce the following CSS output:
-#
-#   .page-title {
-#     font-family: Arial;
-#     font-size: 20px;
-#     font-weight: bold;
-#     color: #ff0000;
-#     padding: 4px;
-#     margin-top: 10px;
-#   }
-#
-# Any number of mixins may be defined and there is no limit on
-# the number that can be included in a particular selector.
-#
-# Mixin definitions can also include references to other mixins.
-# E.g.
-#
-#   =compound
-#     +highlighted-background
-#     +header-text
-#
-#   =highlighted-background
-#     background:
-#       color: #fc0
-#   =header-text
-#     font:
-#       size: 20px
-#
-# Mixins that only define descendent selectors, can be safely mixed
-# into the top most level of a document.
-#
-# === Arguments
-#
-# Mixins can take arguments which can be used with SassScript:
-#
-#   =sexy-border(!color)
-#     :border
-#       :color = !color
-#       :width 1in
-#       :style dashed
-#   p
-#     +sexy-border("blue")
-#
-# is compiled to:
-#
-#   p {
-#     border-color: #0000ff;
-#     border-width: 1in;
-#     border-style: dashed; }
-#
-# Mixins can also specify default values for their arguments:
-#
-#   =sexy-border(!color, !width = 1in)
-#     :border
-#       :color = !color
-#       :width = !width
-#       :style dashed
-#   p
-#     +sexy-border("blue")
-#
-# is compiled to:
-#
-#   p {
-#     border-color: #0000ff;
-#     border-width: 1in;
-#     border-style: dashed; }
-#
-# == Comments
-#
-# === Silent Comments
-#
-# It's simple to add "silent" comments,
-# which don't output anything to the CSS document,
-# to a Sass document.
-# Simply use the familiar C-style notation for a one-line comment, "//",
-# at the normal indentation level and all text following it won't be output.
-# For example:
-#
-#   // A very awesome rule.
-#   #awesome.rule
-#     // An equally awesome attribute.
-#     :awesomeness very
-#
-# becomes
-#
-#   #awesome.rule {
-#     awesomeness: very; }
-#
-# You can also nest text beneath a comment to comment out a whole block.
-# For example:
-#
-#   // A very awesome rule
-#   #awesome.rule
-#     // Don't use these attributes
-#       color: green
-#       font-size: 10em
-#     color: red
-#
-# becomes
-#
-#   #awesome.rule {
-#     color: red; }
-#
-# === Loud Comments
-#
-# "Loud" comments are just as easy as silent ones.
-# These comments output to the document as CSS comments,
-# and thus use the same opening sequence: "/*".
-# For example:
-#
-#   /* A very awesome rule.
-#   #awesome.rule
-#     /* An equally awesome attribute.
-#     :awesomeness very
-#
-# becomes
-#
-#   /* A very awesome rule. */
-#   #awesome.rule {
-#     /* An equally awesome attribute. */
-#     awesomeness: very; }
-#
-# You can also nest content beneath loud comments. For example:
-#
-#   #pbj
-#     /* This rule describes
-#       the styling of the element
-#       that represents
-#       a peanut butter and jelly sandwich.
-#     :background-image url(/images/pbj.png)
-#     :color red
-#
-# becomes
-#
-#   #pbj {
-#     /* This rule describes
-#      * the styling of the element
-#      * that represents
-#      * a peanut butter and jelly sandwich. */
-#     background-image: url(/images/pbj.png);
-#     color: red; }
-#
-# == Output Style
-#
-# Although the default CSS style that Sass outputs is very nice,
-# and reflects the structure of the document in a similar way that Sass does,
-# sometimes it's good to have other formats available.
-#
-# Sass allows you to choose between three different output styles
-# by setting the <tt>:style</tt> option.
-# In Rails, this is done by setting <tt>Sass::Plugin.options[:style]</tt>;
-# outside Rails, it's done by passing an options hash with </tt>:style</tt> set.
-#
-# === <tt>:nested</tt>
-#
-# Nested style is the default Sass style,
-# because it reflects the structure of the document
-# in much the same way Sass does.
-# Each attribute has its own line,
-# but the indentation isn't constant.
-# Each rule is indented based on how deeply it's nested.
-# For example:
-#
-#   #main {
-#     color: #fff;
-#     background-color: #000; }
-#     #main p {
-#       width: 10em; }
-#
-#   .huge {
-#     font-size: 10em;
-#     font-weight: bold;
-#     text-decoration: underline; }
-#
-# Nested style is very useful when looking at large CSS files
-# for the same reason Sass is useful for making them:
-# it allows you to very easily grasp the structure of the file
-# without actually reading anything.
-#
-# === <tt>:expanded</tt>
-#
-# Expanded is the typical human-made CSS style,
-# with each attribute and rule taking up one line.
-# Attributes are indented within the rules,
-# but the rules aren't indented in any special way.
-# For example:
-#
-#   #main {
-#     color: #fff;
-#     background-color: #000;
-#   }
-#   #main p {
-#     width: 10em;
-#   }
-#
-#   .huge {
-#     font-size: 10em;
-#     font-weight: bold;
-#     text-decoration: underline;
-#   }
-#
-# === <tt>:compact</tt>
-#
-# Compact style, as the name would imply,
-# takes up less space than Nested or Expanded.
-# However, it's also harder to read.
-# Each CSS rule takes up only one line,
-# with every attribute defined on that line.
-# Nested rules are placed next to each other with no newline,
-# while groups of rules have newlines between them.
-# For example:
-#
-#   #main { color: #fff; background-color: #000; }
-#   #main p { width: 10em; }
-#
-#   .huge { font-size: 10em; font-weight: bold; text-decoration: underline; }
-#
-# === <tt>:compressed</tt>
-#
-# Compressed style takes up the minimum amount of space possible,
-# having no whitespace except that necessary to separate selectors
-# and a newline at the end of the file.
-# It's not meant to be human-readable.
-# For example:
-#
-#   #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline}
-#
-# == Sass Options
-#
-# Options can be set by setting the <tt>Sass::Plugin.options</tt> hash
-# in <tt>environment.rb</tt> in Rails...
-#
-#   Sass::Plugin.options[:style] = :compact
-#
-# ...or by setting the <tt>Merb::Plugin.config[:sass]</tt> hash in <tt>init.rb</tt> in Merb...
-#
-#   Merb::Plugin.config[:sass][:style] = :compact
-# 
-# ...or by passing an options hash to Sass::Engine.new.
-# Available options are:
-#
-# [<tt>:style</tt>]             Sets the style of the CSS output.
-#                               See the section on Output Style, above.
-#
-# [<tt>:attribute_syntax</tt>]  Forces the document to use one syntax for attributes.
-#                               If the correct syntax isn't used, an error is thrown.
-#                               <tt>:normal</tt> forces the use of a colon
-#                               before the attribute name.
-#                               For example: <tt>:color #0f3</tt>
-#                               or <tt>:width = !main_width</tt>.
-#                               <tt>:alternate</tt> forces the use of a colon or equals sign
-#                               after the attribute name.
-#                               For example: <tt>color: #0f3</tt>
-#                               or <tt>width = !main_width</tt>.
-#                               By default, either syntax is valid.
-#
-# [<tt>:never_update</tt>]      Whether the CSS files should never be updated,
-#                               even if the template file changes.
-#                               Setting this to true may give small performance gains.
-#                               It always defaults to false.
-#                               Only has meaning within Ruby on Rails or Merb.
-#
-# [<tt>:always_update</tt>]     Whether the CSS files should be updated every
-#                               time a controller is accessed,
-#                               as opposed to only when the template has been modified.
-#                               Defaults to false.
-#                               Only has meaning within Ruby on Rails or Merb.
-#
-# [<tt>:always_check</tt>]      Whether a Sass template should be checked for updates every
-#                               time a controller is accessed,
-#                               as opposed to only when the Rails server starts.
-#                               If a Sass template has been updated,
-#                               it will be recompiled and will overwrite the corresponding CSS file.
-#                               Defaults to false in production mode, true otherwise.
-#                               Only has meaning within Ruby on Rails or Merb.
-#
-# [<tt>:full_exception</tt>]    Whether an error in the Sass code
-#                               should cause Sass to provide a detailed description.
-#                               If set to true, the specific error will be displayed
-#                               along with a line number and source snippet.
-#                               Otherwise, a simple uninformative error message will be displayed.
-#                               Defaults to false in production mode, true otherwise.
-#                               Only has meaning within Ruby on Rails or Merb.
-#
-# [<tt>:template_location</tt>] A path to the root sass template directory for you application.
-#                               If a hash, :css_location is ignored and this option designates
-#                               both a mapping between input and output directories.
-#                               May also be given a list of 2-element lists, instead of a hash.
-#                               Defaults to <tt>RAILS_ROOT + "/public/stylesheets/sass"</tt>
-#                               or <tt>MERB_ROOT + "/public/stylesheets/sass"</tt>.
-#                               Only has meaning within Ruby on Rails or Merb.
-#                               This will be derived from the :css_location path list if not provided 
-#                               by appending a folder of "sass" to each corresponding css location.
-#
-# [<tt>:css_location</tt>]      The path where CSS output should be written to.
-#                               This option is ignored when :template_location is a Hash.
-#                               Defaults to <tt>RAILS_ROOT + "/public/stylesheets"</tt>
-#                               or <tt>MERB_ROOT + "/public/stylesheets"</tt>.
-#                               Only has meaning within Ruby on Rails or Merb.
-#
-# [<tt>:filename</tt>]          The filename of the file being rendered.
-#                               This is used solely for reporting errors,
-#                               and is automatically set when using Rails or Merb.
-#
-# [<tt>:load_paths</tt>]        An array of filesystem paths which should be searched
-#                               for Sass templates imported with the "@import" directive.
-#                               This defaults to the working directory and, in Rails or Merb,
-#                               whatever <tt>:template_location</tt> is.
-#
-# [<tt>:line_numbers</tt>]      When set to true, causes the line number and file
-#                               where a selector is defined to be emitted into the compiled CSS
-#                               as a comment. Useful for debugging especially when using imports
-#                               and mixins.
-module Sass
-  extend Haml::Version
-
-  # A string representing the version of Sass.
-  # A more fine-grained representation is available from Sass.version.
-  VERSION = version[:string] unless defined?(Sass::VERSION)
-
-end
-
-require 'haml/util'
-require 'sass/engine'
-require 'sass/plugin' if defined?(Merb::Plugins)