haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/doc-src/SCSS_FOR_SASS_USERS.md

@@ -1,155 +0,0 @@
-# Intro to SCSS for Sass Users
-
-Sass 3 introduces a new syntax known as SCSS
-which is fully compatible with the syntax of CSS3,
-while still supporting the full power of Sass.
-This means that every valid CSS3 stylesheet
-is a valid SCSS file with the same meaning.
-In addition, SCSS understands most CSS hacks
-and vendor-specific syntax, such as [IE's old `filter` syntax](http://msdn.microsoft.com/en-us/library/ms533754%28VS.85%29.aspx).
-
-Since SCSS is a CSS extension,
-everything that works in CSS works in SCSS.
-This means that for a Sass user to understand it,
-they need only understand how the Sass extensions work.
-Most of these, such as variables, parent references, and directives work the same;
-the only difference is that SCSS requires semicolons
-and brackets instead of newlines and indentation.
-For example, a simple rule in Sass:
-
-    #sidebar
-      width: 30%
-      background-color: #faa
-
-could be converted to SCSS just by adding brackets and semicolons:
-
-    #sidebar {
-      width: 30%;
-      background-color: #faa;
-    }
-
-In addition, SCSS is completely whitespace-insensitive.
-That means the above could also be written as:
-
-    #sidebar {width: 30%; background-color: #faa}
-
-There are some differences that are slightly more complicated.
-These are detailed below.
-Note, though, that SCSS uses all the
-{file:SASS_CHANGELOG.md#3-0-0-syntax-changes syntax changes in Sass 3},
-so make sure you understand those before going forward.
-
-## Nested Selectors
-
-To nest selectors, simply define a new ruleset
-inside an existing ruleset:
-
-    #sidebar {
-      a { text-decoration: none; }
-    }
-
-Of course, white space is insignificant
-and the last trailing semicolon is optional
-so you can also do it like this:
-
-    #sidebar { a { text-decoration: none } }
-
-## Nested Properties
-
-To nest properties,
-simply create a new property set
-after an existing property's colon:
-
-    #footer {
-      border: {
-        width: 1px;
-        color: #ccc;
-        style: solid;
-      }
-    }
-
-This compiles to:
-
-    #footer {
-      border-width: 1px;
-      border-color: #cccccc;
-      border-style: solid; }
-
-## Mixins
-
-A mixin is declared with the `@mixin` directive:
-
-    @mixin rounded($amount) {
-      -moz-border-radius: $amount;
-      -webkit-border-radius: $amount;
-      border-radius: $amount;
-    }
-
-A mixin is used with the `@include` directive:
-
-    .box {
-      border: 3px solid #777;
-      @include rounded(0.5em);
-    }
-
-This syntax is also available in the indented syntax,
-although the old `=` and `+` syntax still works.
-
-This is rather verbose compared to the `=` and `+` characters used in Sass syntax.
-This is because the SCSS format is designed for CSS compatibility rather than conciseness,
-and creating new syntax when the CSS directive syntax already exists
-adds new syntax needlessly and
-could create incompatibilities with future versions of CSS.
-
-## Comments
-
-Like Sass, SCSS supports both comments that are preserved in the CSS output
-and comments that aren't.
-However, SCSS's comments are significantly more flexible.
-It supports standard multiline CSS comments with `/* */`,
-which are preserved where possible in the output.
-These comments can have whatever formatting you like;
-Sass will do its best to format them nicely.
-
-SCSS also uses `//` for comments that are thrown away, like Sass.
-Unlike Sass, though, `//` comments in SCSS may appear anywhere
-and last only until the end of the line.
-
-For example:
-
-    /* This comment is
-     * several lines long.
-     * since it uses the CSS comment syntax,
-     * it will appear in the CSS output. */
-    body { color: black; }
-
-    // These comments are only one line long each.
-    // They won't appear in the CSS output,
-    // since they use the single-line comment syntax.
-    a { color: green; }
-
-is compiled to:
-
-    /* This comment is
-     * several lines long.
-     * since it uses the CSS comment syntax,
-     * it will appear in the CSS output. */
-    body {
-      color: black; }
-
-    a {
-      color: green; }
-
-## `@import`
-
-The `@import` directive in SCSS functions just like that in Sass,
-except that it takes a quoted string to import.
-For example, this Sass:
-
-    @import themes/dark
-    @import font.sass
-
-would be this SCSS:
-
-    @import "themes/dark";
-    @import "font.sass";

data/vendor/sass/ext/extconf.rb

@@ -1,10 +0,0 @@
-root = File.expand_path("../..", __FILE__)
-File.open(File.expand_path("lib/sass/root.rb", root), "w") do |f|
-  f << <<-RUBY
-module Sass
-  ROOT_DIR = #{root.inspect}
-end
-  RUBY
-end
-
-File.open('Makefile', 'w') { |f| f.puts("install:\n\t$(exit 0)") }

data/vendor/sass/extra/update_watch.rb

@@ -1,13 +0,0 @@
-require 'rubygems'
-require 'sinatra'
-require 'json'
-set :port, 3124
-set :environment, :production
-enable :lock
-Dir.chdir(File.dirname(__FILE__) + "/..")
-
-post "/" do
-  puts "Recieved payload!"
-  puts "Rev: #{`git name-rev HEAD`.strip}"
-  system %{rake handle_update --trace REF=#{JSON.parse(params["payload"])["ref"].inspect}}
-end

data/vendor/sass/init.rb

@@ -1,18 +0,0 @@
-begin
-  require File.join(File.dirname(__FILE__), 'lib', 'sass') # From here
-rescue LoadError
-  begin
-    require 'sass' # From gem
-  rescue LoadError => e
-    # gems:install may be run to install Haml with the skeleton plugin
-    # but not the gem itself installed.
-    # Don't die if this is the case.
-    raise e unless defined?(Rake) &&
-      (Rake.application.top_level_tasks.include?('gems') ||
-        Rake.application.top_level_tasks.include?('gems:install'))
-  end
-end
-
-# Load Sass.
-# Sass may be undefined if we're running gems:install.
-require 'sass/plugin' if defined?(Sass)

data/vendor/sass/lib/sass.rb

@@ -1,73 +0,0 @@
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
-# This is necessary to set so that the Haml code that tries to load Sass
-# knows that Sass is indeed loading,
-# even if there's some crazy autoload stuff going on.
-SASS_BEGUN_TO_LOAD = true unless defined?(SASS_BEGUN_TO_LOAD)
-
-require 'sass/version'
-
-# The module that contains everything Sass-related:
-#
-# * {Sass::Engine} is the class used to render Sass/SCSS within Ruby code.
-# * {Sass::Plugin} is interfaces with web frameworks (Rails and Merb in particular).
-# * {Sass::SyntaxError} is raised when Sass encounters an error.
-# * {Sass::CSS} handles conversion of CSS to Sass.
-#
-# Also see the {file:SASS_REFERENCE.md full Sass reference}.
-module Sass
-  # Compile a Sass or SCSS string to CSS.
-  # Defaults to SCSS.
-  #
-  # @param contents [String] The contents of the Sass file.
-  # @param options [{Symbol => Object}] An options hash;
-  #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
-  # @raise [Sass::SyntaxError] if there's an error in the document
-  # @raise [Encoding::UndefinedConversionError] if the source encoding
-  #   cannot be converted to UTF-8
-  # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
-  def self.compile(contents, options = {})
-    options[:syntax] ||= :scss
-    Engine.new(contents, options).to_css
-  end
-
-  # Compile a file on disk to CSS.
-  #
-  # @param filename [String] The path to the Sass, SCSS, or CSS file on disk.
-  # @param options [{Symbol => Object}] An options hash;
-  #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
-  # @raise [Sass::SyntaxError] if there's an error in the document
-  # @raise [Encoding::UndefinedConversionError] if the source encoding
-  #   cannot be converted to UTF-8
-  # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
-  #
-  # @overload compile_file(filename, options = {})
-  #   Return the compiled CSS rather than writing it to a file.
-  #
-  #   @return [String] The compiled CSS.
-  #
-  # @overload compile_file(filename, css_filename, options = {})
-  #   Write the compiled CSS to a file.
-  #
-  #   @param css_filename [String] The location to which to write the compiled CSS.
-  def self.compile_file(filename, *args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    css_filename = args.shift
-    result = Sass::Engine.for_file(filename, options).render
-    if css_filename
-      options[:css_filename] ||= css_filename
-      open(css_filename,"w") {|css_file| css_file.write(result)}
-      nil
-    else
-      result
-    end
-  end
-end
-
-require 'sass/logger'
-require 'sass/util'
-
-require 'sass/engine'
-require 'sass/plugin' if defined?(Merb::Plugins)
-require 'sass/railtie'

data/vendor/sass/lib/sass/cache_stores.rb

@@ -1,15 +0,0 @@
-require 'stringio'
-
-module Sass
-  # Sass cache stores are in charge of storing cached information,
-  # especially parse trees for Sass documents.
-  #
-  # User-created importers must inherit from {CacheStores::Base}.
-  module CacheStores
-  end
-end
-
-require 'sass/cache_stores/base'
-require 'sass/cache_stores/filesystem'
-require 'sass/cache_stores/memory'
-require 'sass/cache_stores/chain'

data/vendor/sass/lib/sass/cache_stores/base.rb

@@ -1,86 +0,0 @@
-module Sass
-  module CacheStores
-    # An abstract base class for backends for the Sass cache.
-    # Any key-value store can act as such a backend;
-    # it just needs to implement the
-    # \{#_store} and \{#_retrieve} methods.
-    #
-    # To use a cache store with Sass,
-    # use the {file:SASS_REFERENCE.md#cache_store-option `:cache_store` option}.
-    #
-    # @abstract
-    class Base
-      # Store cached contents for later retrieval
-      # Must be implemented by all CacheStore subclasses
-      #
-      # Note: cache contents contain binary data.
-      #
-      # @param key [String] The key to store the contents under
-      # @param version [String] The current sass version.
-      #                Cached contents must not be retrieved across different versions of sass.
-      # @param sha [String] The sha of the sass source.
-      #                Cached contents must not be retrieved if the sha has changed.
-      # @param contents [String] The contents to store.
-      def _store(key, version, sha, contents)
-        raise "#{self.class} must implement #_store."
-      end
-
-      # Retrieved cached contents.
-      # Must be implemented by all subclasses.
-      # 
-      # Note: if the key exists but the sha or version have changed,
-      # then the key may be deleted by the cache store, if it wants to do so.
-      #
-      # @param key [String] The key to retrieve
-      # @param version [String] The current sass version.
-      #                Cached contents must not be retrieved across different versions of sass.
-      # @param sha [String] The sha of the sass source.
-      #                Cached contents must not be retrieved if the sha has changed.
-      # @return [String] The contents that were previously stored.
-      # @return [NilClass] when the cache key is not found or the version or sha have changed.
-      def _retrieve(key, version, sha)
-        raise "#{self.class} must implement #_retrieve."
-      end
-
-      # Store a {Sass::Tree::RootNode}.
-      #
-      # @param key [String] The key to store it under.
-      # @param sha [String] The checksum for the contents that are being stored.
-      # @param obj [Object] The object to cache.
-      def store(key, sha, root)
-        _store(key, Sass::VERSION, sha, Marshal.dump(root))
-      rescue TypeError, LoadError => e
-        Sass::Util.sass_warn "Warning. Error encountered while saving cache #{path_to(key)}: #{e}"
-      end
-
-      # Retrieve a {Sass::Tree::RootNode}.
-      #
-      # @param key [String] The key the root element was stored under.
-      # @param sha [String] The checksum of the root element's content.
-      # @return [Object] The cached object.
-      def retrieve(key, sha)
-        contents = _retrieve(key, Sass::VERSION, sha)
-        Marshal.load(contents) if contents
-      rescue EOFError, TypeError, ArgumentError, LoadError => e
-        Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
-      end
-
-      # Return the key for the sass file.
-      #
-      # The `(sass_dirname, sass_basename)` pair
-      # should uniquely identify the Sass document,
-      # but otherwise there are no restrictions on their content.
-      #
-      # @param sass_dirname [String]
-      #   The fully-expanded location of the Sass file.
-      #   This corresponds to the directory name on a filesystem.
-      # @param sass_basename [String] The name of the Sass file that is being referenced.
-      #   This corresponds to the basename on a filesystem.
-      def key(sass_dirname, sass_basename)
-        dir = Digest::SHA1.hexdigest(sass_dirname)
-        filename = "#{sass_basename}c"
-        "#{dir}/#{filename}"
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/cache_stores/chain.rb

@@ -1,33 +0,0 @@
-module Sass
-  module CacheStores
-    # A meta-cache that chains multiple caches together.
-    # Specifically:
-    #
-    # * All `#store`s are passed to all caches.
-    # * `#retrieve`s are passed to each cache until one has a hit.
-    # * When one cache has a hit, the value is `#store`d in all earlier caches.
-    class Chain < Base
-      # Create a new cache chaining the given caches.
-      #
-      # @param caches [Array<Sass::CacheStores::Base>] The caches to chain.
-      def initialize(*caches)
-        @caches = caches
-      end
-
-      # @see Base#store
-      def store(key, sha, obj)
-        @caches.each {|c| c.store(key, sha, obj)}
-      end
-
-      # @see Base#retrieve
-      def retrieve(key, sha)
-        @caches.each_with_index do |c, i|
-          next unless obj = c.retrieve(key, sha)
-          @caches[0...i].each {|c| c.store(key, sha, obj)}
-          return obj
-        end
-        nil
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/cache_stores/filesystem.rb

@@ -1,60 +0,0 @@
-require 'fileutils'
-
-module Sass
-  module CacheStores
-    # A backend for the Sass cache using the filesystem.
-    class Filesystem < Base
-      # The directory where the cached files will be stored.
-      #
-      # @return [String]
-      attr_accessor :cache_location
-
-      # @param cache_location [String] see \{#cache\_location}
-      def initialize(cache_location)
-        @cache_location = cache_location
-      end
-
-      # @see Base#\_retrieve
-      def _retrieve(key, version, sha)
-        return unless File.readable?(path_to(key))
-        contents = nil
-        File.open(path_to(key), "rb") do |f|
-          if f.readline("\n").strip == version && f.readline("\n").strip == sha
-            return f.read
-          end
-        end
-        File.unlink path_to(key)
-        nil
-      rescue EOFError, TypeError, ArgumentError => e
-        Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
-      end
-
-      # @see Base#\_store
-      def _store(key, version, sha, contents)
-        # return unless File.writable?(File.dirname(@cache_location))
-        # return if File.exists?(@cache_location) && !File.writable?(@cache_location)
-        compiled_filename = path_to(key)
-        # return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
-        # return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
-        FileUtils.mkdir_p(File.dirname(compiled_filename))
-        File.open(compiled_filename, "wb") do |f|
-          f.puts(version)
-          f.puts(sha)
-          f.write(contents)
-        end
-      rescue Errno::EACCES
-        #pass
-      end
-
-      private
-
-      # Returns the path to a file for the given key.
-      #
-      # @param key [String]
-      # @return [String] The path to the cache file.
-      def path_to(key)
-        File.join(cache_location, key)
-      end
-    end
-  end
-end