sass 3.1.0.alpha.2

data/VERSION

@@ -0,0 +1 @@
+3.1.0.alpha.2

data/VERSION_NAME

@@ -0,0 +1 @@
+Bleeding Edge

data/bin/css2sass

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/sass'
+require 'sass/exec'
+
+warn <<END
+DEPRECATION WARNING:
+The css2sass tool is deprecated and will be removed in Sass 3.2.
+Use the sass-convert tool instead.
+END
+
+opts = Sass::Exec::SassConvert.new(%w[--from css --to sass] + ARGV)
+opts.parse!

data/bin/sass

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# The command line Sass parser.
+
+require File.dirname(__FILE__) + '/../lib/sass'
+require 'sass/exec'
+
+opts = Sass::Exec::Sass.new(ARGV)
+opts.parse!

data/bin/sass-convert

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/sass'
+require 'sass/exec'
+
+opts = Sass::Exec::SassConvert.new(ARGV)
+opts.parse!

data/extra/update_watch.rb

@@ -0,0 +1,13 @@
+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/init.rb

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

@@ -0,0 +1,71 @@
+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 [String] The compiled CSS.
+  #
+  # @overload compile_file(filename, css_filename, options = {})
+  #   @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
+    options[:css_filename] = css_filename
+    result = Sass::Engine.for_file(filename, options).render
+    if css_filename
+      open(css_filename,"w") {|css_file| css_file.write(result) }
+      nil
+    else
+      result
+    end
+  end
+end
+
+require 'sass/util'
+
+dir = Sass::Util.scope("vendor/fssm/lib")
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'sass/engine'
+require 'sass/plugin' if defined?(Merb::Plugins)
+require 'sass/railtie'

data/lib/sass/cache_store.rb

@@ -0,0 +1,208 @@
+require 'stringio'
+
+module Sass
+  # 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}.
+  class CacheStore
+    # 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, Sass::Util.dump(root))
+    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)
+      Sass::Util.load(contents) if contents
+    rescue EOFError, TypeError, ArgumentError => e
+      raise
+      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
+
+  # A backend for the Sass cache using the filesystem.
+  class FileCacheStore < CacheStore
+    # The directory where the cached files will be stored.
+    #
+    # @return [String]
+    attr_accessor :cache_location
+
+    # Create a new FileCacheStore.
+    #
+    # @param cache_location [String] see \{#cache\_location}
+    def initialize(cache_location)
+      @cache_location = cache_location
+    end
+
+    # @see {CacheStore#\_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 {CacheStore#\_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
+    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
+
+  # A backend for the Sass cache using in-process memory.
+  class InMemoryCacheStore < CacheStore
+    # Since the {InMemoryCacheStore} is stored in the Sass tree's options hash,
+    # when the options get serialized as part of serializing the tree,
+    # you get crazy exponential growth in the size of the cached objects
+    # unless you don't dump the cache.
+    #
+    # @private
+    def _dump(depth)
+      ""
+    end
+
+    # If we deserialize this class, just make a new empty one.
+    #
+    # @private
+    def self._load(repr)
+      InMemoryCacheStore.new
+    end
+
+    # Create a new, empty cache store.
+    def initialize
+      @contents = {}
+    end
+
+    # @see CacheStore#_retrieve
+    def _retrieve(key, version, sha)
+      if @contents.has_key?(key)
+        return unless @contents[key][:version] == version
+        return unless @contents[key][:sha] == sha
+        return @contents[key][:contents]
+      end
+    end
+    
+    # @see CacheStore#_store
+    def _store(key, version, sha, contents)
+      @contents[key] = {
+        :version => version,
+        :sha => sha,
+        :contents => contents
+      }
+    end
+    
+    # Destructively clear the cache.
+    def reset!
+      @contents = {}
+    end
+  end
+
+  # Doesn't store anything, but records what things it should have stored.
+  # This doesn't currently have any use except for testing and debugging.
+  #
+  # @private
+  class NullCacheStore < CacheStore
+    def initialize
+      @keys = {}
+    end
+
+    def _retrieve(key, version, sha)
+      nil
+    end
+    
+    def _store(key, version, sha, contents)
+      @keys[key] = true
+    end
+    
+    def was_set?(key)
+      @keys[key]
+    end
+  end
+end

data/lib/sass/callbacks.rb

@@ -0,0 +1,66 @@
+module Sass
+  # A lightweight infrastructure for defining and running callbacks.
+  # Callbacks are defined using \{#define\_callback\} at the class level,
+  # and called using `run_#{name}` at the instance level.
+  #
+  # Clients can add callbacks by calling the generated `on_#{name}` method,
+  # and passing in a block that's run when the callback is activated.
+  #
+  # @example Define a callback
+  #   class Munger
+  #     extend Sass::Callbacks
+  #     define_callback :string_munged
+  #
+  #     def munge(str)
+  #       res = str.gsub(/[a-z]/, '\1\1')
+  #       run_string_munged str, res
+  #       res
+  #     end
+  #   end
+  #
+  # @example Use a callback
+  #   m = Munger.new
+  #   m.on_string_munged {|str, res| puts "#{str} was munged into #{res}!"}
+  #   m.munge "bar" #=> bar was munged into bbaarr!
+  module Callbacks
+    # Automatically includes {InstanceMethods}
+    # when something extends this module.
+    #
+    # @param base [Module]
+    def self.extended(base)
+      base.send(:include, InstanceMethods)
+    end
+    protected
+
+    module InstanceMethods
+      # Removes all callbacks registered against this object.
+      def clear_callbacks!
+        @_sass_callbacks = {}
+      end
+    end
+
+    # Define a callback with the given name.
+    # This will define an `on_#{name}` method
+    # that registers a block,
+    # and a `run_#{name}` method that runs that block
+    # (optionall with some arguments).
+    #
+    # @param name [Symbol] The name of the callback
+    # @return [void]
+    def define_callback(name)
+      class_eval <<RUBY
+def on_#{name}(&block)
+  @_sass_callbacks ||= {}
+  (@_sass_callbacks[#{name.inspect}] ||= []) << block
+end
+
+def run_#{name}(*args)
+  return unless @_sass_callbacks
+  return unless @_sass_callbacks[#{name.inspect}]
+  @_sass_callbacks[#{name.inspect}].each {|c| c[*args]}
+end
+private :run_#{name}
+RUBY
+    end
+  end
+end

data/lib/sass/css.rb

@@ -0,0 +1,294 @@
+require File.dirname(__FILE__) + '/../sass'
+require 'sass/tree/node'
+require 'sass/scss/css_parser'
+require 'strscan'
+
+module Sass
+  # This class converts CSS documents into Sass or SCSS templates.
+  # It works by parsing the CSS document into a {Sass::Tree} structure,
+  # and then applying various transformations to the structure
+  # to produce more concise and idiomatic Sass/SCSS.
+  #
+  # Example usage:
+  #
+  #     Sass::CSS.new("p { color: blue }").render(:sass) #=> "p\n  color: blue"
+  #     Sass::CSS.new("p { color: blue }").render(:scss) #=> "p {\n  color: blue; }"
+  class CSS
+    # @param template [String] The CSS stylesheet.
+    #   This stylesheet can be encoded using any encoding
+    #   that can be converted to Unicode.
+    #   If the stylesheet contains an `@charset` declaration,
+    #   that overrides the Ruby encoding
+    #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
+    # @option options :old [Boolean] (false)
+    #     Whether or not to output old property syntax
+    #     (`:color blue` as opposed to `color: blue`).
+    #     This is only meaningful when generating Sass code,
+    #     rather than SCSS.
+    def initialize(template, options = {})
+      if template.is_a? IO
+        template = template.read
+      end
+
+      @options = options.dup
+      # Backwards compatibility
+      @options[:old] = true if @options[:alternate] == false
+      @template = template
+    end
+
+    # Converts the CSS template into Sass or SCSS code.
+    #
+    # @param fmt [Symbol] `:sass` or `:scss`, designating the format to return.
+    # @return [String] The resulting Sass or SCSS code
+    # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
+    def render(fmt = :sass)
+      check_encoding!
+      build_tree.send("to_#{fmt}", @options).strip + "\n"
+    rescue Sass::SyntaxError => err
+      err.modify_backtrace(:filename => @options[:filename] || '(css)')
+      raise err
+    end
+
+    # Returns the original encoding of the document,
+    # or `nil` under Ruby 1.8.
+    #
+    # @return [Encoding, nil]
+    # @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 source_encoding
+      check_encoding!
+      @original_encoding
+    end
+
+    private
+
+    def check_encoding!
+      return if @checked_encoding
+      @checked_encoding = true
+      @template, @original_encoding = Sass::Util.check_sass_encoding(@template) do |msg, line|
+        raise Sass::SyntaxError.new(msg, :line => line)
+      end
+    end
+
+    # Parses the CSS template and applies various transformations
+    #
+    # @return [Tree::Node] The root node of the parsed tree
+    def build_tree
+      root = Sass::SCSS::CssParser.new(@template).parse
+      expand_commas      root
+      parent_ref_rules   root
+      remove_parent_refs root
+      flatten_rules      root
+      fold_commas        root
+      root
+    end
+
+    # Transform
+    #
+    #     foo, bar, baz
+    #       color: blue
+    #
+    # into
+    #
+    #     foo
+    #       color: blue
+    #     bar
+    #       color: blue
+    #     baz
+    #       color: blue
+    #
+    # @param root [Tree::Node] The parent node
+    def expand_commas(root)
+      root.children.map! do |child|
+        unless child.is_a?(Tree::RuleNode) && child.rule.first.include?(',')
+          expand_commas(child) if child.is_a?(Tree::DirectiveNode)
+          next child
+        end
+        child.rule.first.split(',').map do |rule|
+          node = Tree::RuleNode.new([rule.strip])
+          node.children = child.children
+          node
+        end
+      end
+      root.children.flatten!
+    end
+
+    # Make rules use parent refs so that
+    #
+    #     foo
+    #       color: green
+    #     foo.bar
+    #       color: blue
+    #
+    # becomes
+    #
+    #     foo
+    #       color: green
+    #       &.bar
+    #         color: blue
+    #
+    # This has the side effect of nesting rules,
+    # so that
+    #
+    #     foo
+    #       color: green
+    #     foo bar
+    #       color: red
+    #     foo baz
+    #       color: blue
+    #
+    # becomes
+    #
+    #     foo
+    #       color: green
+    #       & bar
+    #         color: red
+    #       & baz
+    #         color: blue
+    #
+    # @param root [Tree::Node] The parent node
+    def parent_ref_rules(root)
+      current_rule = nil
+      root.children.map! do |child|
+        unless child.is_a?(Tree::RuleNode)
+          parent_ref_rules(child) if child.is_a?(Tree::DirectiveNode)
+          next child
+        end
+
+        first, rest = child.rule.first.scan(/\A(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?\Z/m).first
+
+        if current_rule.nil? || current_rule.rule.first != first
+          current_rule = Tree::RuleNode.new([first])
+        end
+
+        if rest
+          child.rule = ["&" + rest]
+          current_rule << child
+        else
+          current_rule.children += child.children
+        end
+
+        current_rule
+      end
+      root.children.compact!
+      root.children.uniq!
+
+      root.children.each { |v| parent_ref_rules(v) }
+    end
+
+    # Remove useless parent refs so that
+    #
+    #     foo
+    #       & bar
+    #         color: blue
+    #
+    # becomes
+    #
+    #     foo
+    #       bar
+    #         color: blue
+    #
+    # @param root [Tree::Node] The parent node
+    def remove_parent_refs(root)
+      root.children.each do |child|
+        case child
+        when Tree::RuleNode
+          child.rule.first.gsub! /^& +/, ''
+          remove_parent_refs child
+        when Tree::DirectiveNode
+          remove_parent_refs child
+        end
+      end
+    end
+
+    # Flatten rules so that
+    #
+    #     foo
+    #       bar
+    #         color: red
+    #
+    # becomes
+    #
+    #     foo bar
+    #       color: red
+    #
+    # and
+    #
+    #     foo
+    #       &.bar
+    #         color: blue
+    #
+    # becomes
+    #
+    #     foo.bar
+    #       color: blue
+    #
+    # @param root [Tree::Node] The parent node
+    def flatten_rules(root)
+      root.children.each do |child|
+        case child
+        when Tree::RuleNode
+          flatten_rule(child)
+        when Tree::DirectiveNode
+          flatten_rules(child)
+        end
+      end
+    end
+
+    # Flattens a single rule
+    #
+    # @param rule [Tree::RuleNode] The candidate for flattening
+    # @see #flatten_rules
+    def flatten_rule(rule)
+      while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
+        child = rule.children.first
+
+        if child.rule.first[0] == ?&
+          rule.rule = [child.rule.first.gsub(/^&/, rule.rule.first)]
+        else
+          rule.rule = ["#{rule.rule.first} #{child.rule.first}"]
+        end
+
+        rule.children = child.children
+      end
+
+      flatten_rules(rule)
+    end
+
+    # Transform
+    #
+    #     foo
+    #       bar
+    #         color: blue
+    #       baz
+    #         color: blue
+    #
+    # into
+    #
+    #     foo
+    #       bar, baz
+    #         color: blue
+    #
+    # @param rule [Tree::RuleNode] The candidate for flattening
+    def fold_commas(root)
+      prev_rule = nil
+      root.children.map! do |child|
+        unless child.is_a?(Tree::RuleNode)
+          fold_commas(child) if child.is_a?(Tree::DirectiveNode)
+          next child
+        end
+
+        if prev_rule && prev_rule.children == child.children
+          prev_rule.rule.first << ", #{child.rule.first}"
+          next nil
+        end
+
+        fold_commas(child)
+        prev_rule = child
+        child
+      end
+      root.children.compact!
+    end
+  end
+end