merbjedi-haml 2.1.0

data/lib/haml/shared.rb

@@ -0,0 +1,45 @@
+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/lib/haml/template.rb

@@ -0,0 +1,51 @@
+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/lib/haml/template/patch.rb

@@ -0,0 +1,58 @@
+# 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/lib/haml/template/plugin.rb

@@ -0,0 +1,72 @@
+# :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/lib/haml/util.rb

@@ -0,0 +1,77 @@
+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/lib/haml/version.rb

@@ -0,0 +1,47 @@
+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/lib/sass.rb

@@ -0,0 +1,1062 @@
+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)