compass 0.8.16

data/lib/compass/sass_extensions/monkey_patches.rb

@@ -0,0 +1,3 @@
+['stylesheet_updating'].each do |patch|
+  require File.join(File.dirname(__FILE__), 'monkey_patches', patch)
+end

data/lib/compass/sass_extensions/monkey_patches/stylesheet_updating.rb

@@ -0,0 +1,23 @@
+require 'sass/plugin'
+
+# XXX: We can remove this monkeypatch once Sass 2.2 is released.
+module Sass::Plugin
+  class << self
+    unless method_defined?(:exact_stylesheet_needs_update?)
+      def stylesheet_needs_update?(name, template_path, css_path)
+        css_file = css_filename(name, css_path)
+        template_file = template_filename(name, template_path)
+        exact_stylesheet_needs_update?(css_file, template_file)
+      end
+      def exact_stylesheet_needs_update?(css_file, template_file)
+        if !File.exists?(css_file)
+          return true
+        else
+          css_mtime = File.mtime(css_file)
+          File.mtime(template_file) > css_mtime ||
+            dependencies(template_file).any?(&dependency_updated?(css_mtime))
+        end
+      end
+    end
+  end
+end

data/lib/compass/test_case.rb

@@ -0,0 +1,38 @@
+module Compass
+  # Write your unit test like this if you want to make sure all your stylesheets compile.
+  #
+  # require 'compass/test_case'
+  # class StylesheetsTest < Compass::TestCase
+  #   def test_stylesheets
+  #     my_sass_files.each do |sass_file|
+  #       assert_compiles(sass_file) do |result|
+  #         assert_not_blank result
+  #       end
+  #     end
+  #   end
+  #   protected
+  #   def my_sass_files
+  #     Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../..", "app/stylesheets/**/[^_]*.sass")))
+  #   end
+  # end
+  class TestCase < (defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase)
+
+    def setup
+      super
+      @last_compile = nil
+    end
+
+    def compile(stylesheet)
+      input =  open(stylesheet)
+      template = input.read()
+      input.close()
+      @last_compile = ::Sass::Engine.new(template, ::Sass::Plugin.engine_options(:filename => stylesheet)).render
+      yield @last_compile if block_given?
+    end
+
+    def assert_compiles(stylesheet, &block)
+      compile(stylesheet, &block)
+    end
+
+  end
+end

data/lib/compass/validator.rb

@@ -0,0 +1,10 @@
+begin
+  require 'rubygems'
+  require 'compass-validator'
+rescue LoadError
+  puts %Q{The Compass CSS Validator could not be loaded. Please install it:
+
+sudo gem install chriseppstein-compass-validator --source http://gems.github.com/
+}
+  exit(1)
+end

data/lib/compass/version.rb

@@ -0,0 +1,57 @@
+module Compass
+  module Version
+    # Returns a hash representing the version.
+    # The :major, :minor, and :teeny keys have their respective numbers.
+    # The :string key contains a human-readable string representation of the version.
+    # The :rev key will have the current revision hash.
+    #
+    # This method swiped from Haml and then modified, some credit goes to Nathan Weizenbaum
+    attr_writer :version
+    def version
+      return @version if defined?(@version)
+
+      read_version_file
+
+      if r = revision
+        @version[:rev] = r
+        @version[:string] << " [#{r[0...7]}]"
+      end
+
+      @version
+    end
+
+    protected
+
+    def scope(file) # :nodoc:
+      File.join(File.dirname(__FILE__), '..', '..', file)
+    end
+
+    def read_version_file
+      require 'yaml'
+      @version = YAML::load(File.read(scope('VERSION.yml')))
+      @version[:string] = "#{@version[:major]}.#{@version[:minor]}.#{@version[:patch]}"
+      @version[:teeny] = @version[:patch]
+    end
+
+    def revision
+      revision_from_git || revision_from_file
+    end
+
+    def revision_from_file
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        rev if rev =~ /[a-f0-9]+/
+      end
+    end
+
+    def revision_from_git
+      if File.exists?(scope('.git/HEAD'))
+        rev = File.read(scope('.git/HEAD')).strip
+        if rev =~ /^ref: (.*)$/
+          rev = File.read(scope(".git/#{$1}")).strip
+        end
+      end
+    end
+
+  end
+end

data/lib/vendor/fssm.rb

@@ -0,0 +1,41 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+module FSSM
+  FileNotFoundError = Class.new(StandardError)
+  CallbackError = Class.new(StandardError)
+  
+  class << self
+    def dbg(msg=nil)
+      STDERR.puts(msg)
+    end
+
+    def monitor(*args, &block)      
+      monitor = FSSM::Monitor.new
+      context = args.empty? ? monitor : monitor.path(*args)
+
+      if block_given?
+        if block.arity == 1
+          block.call(context)
+        else
+          context.instance_eval(&block)
+        end
+      end
+
+      monitor.run
+    end
+  end
+end
+
+require 'thread'
+require 'pathname'
+
+require 'fssm/ext'
+require 'fssm/support'
+require 'fssm/tree'
+require 'fssm/path'
+require 'fssm/state'
+require 'fssm/monitor'
+
+require "fssm/backends/#{FSSM::Support.backend.downcase}"
+FSSM::Backends::Default = FSSM::Backends.const_get(FSSM::Support.backend)

data/lib/vendor/fssm/backends/fsevents.rb

@@ -0,0 +1,37 @@
+require 'fssm/fsevents'
+
+module FSSM::Backends
+  class FSEvents
+    def initialize
+      @handlers = {}
+      @fsevents = []
+    end
+    
+    def add_path(path, preload=true)
+      handler = FSSM::State.new(path)
+      @handlers["#{path}"] = handler
+      
+      fsevent = Rucola::FSEvents.new("#{path}", {:latency => 0.5}) do |events|
+        events.each do |event|
+          handler.refresh(event.path)
+        end
+      end
+      
+      fsevent.create_stream
+      handler.refresh(path.to_pathname, true) if preload
+      fsevent.start
+      @fsevents << fsevent
+    end
+    
+    def run
+      begin
+        OSX.CFRunLoopRun
+      rescue Interrupt
+        @fsevents.each do |fsev|
+          fsev.stop
+        end
+      end
+    end
+
+  end
+end

data/lib/vendor/fssm/backends/polling.rb

@@ -0,0 +1,26 @@
+module FSSM::Backends
+  class Polling
+    def initialize(options={})
+      @handlers  = []
+      @latency   = options[:latency]   || 1
+    end
+
+    def add_path(path, preload=true)
+      handler = FSSM::State.new(path)
+      handler.refresh(path.to_pathname, true) if preload
+      @handlers << handler
+    end
+
+    def run
+      begin
+        loop do
+          start = Time.now.to_f
+          @handlers.each {|handler| handler.refresh}
+          nap_time = @latency - (Time.now.to_f - start)
+          sleep nap_time if nap_time > 0
+        end
+      rescue Interrupt
+      end
+    end
+  end
+end

data/lib/vendor/fssm/cache.rb

@@ -0,0 +1,193 @@
+class FSSM::Cache
+  module Common
+    include Enumerable
+
+    def initialize
+      @children = Hash.new
+    end
+
+    def each(prefix='./', &block)
+      @children.each do |segment, node|
+        cprefix = Pathname.for(prefix.dup).join(segment)
+        block.call(cprefix, node)
+        node.each(cprefix, &block)
+      end
+    end
+
+    protected
+    
+    def with_lock
+      @mutex.lock
+      yield
+      @mutex.unlock
+    end
+    
+    def descendant(path)
+      recurse_on_key(path, false)
+    end
+
+    def descendant!(path)
+      recurse_on_key(path, true)
+    end
+
+    def child(segment)
+      has_child?(segment) ? @children["#{segment}"] : nil
+    end
+
+    def child!(segment)
+      (@children["#{segment}"] ||= Node.new)
+    end
+
+    def has_child?(segment)
+      @children.include?("#{segment}")
+    end
+
+    def remove_child(segment)
+      @children.delete("#{segment}")
+    end
+
+    def remove_children
+      @children.clear
+    end
+
+    def recurse_on_key(key, create)
+      key = sanitize_key(key)
+      node = self
+
+      until key.empty?
+        segment = key.shift
+        node = create ? node.child!(segment) : node.child(segment)
+        return nil unless node
+      end
+
+      node
+    end
+
+    def key_for_path(path)
+      Pathname.for(path).names
+    end
+
+    def relative_path(path)
+      sanitize_path(path, false)
+    end
+
+    def absolute_path(path)
+      sanitize_path(path, true)
+    end
+
+    def sanitize_path(path, absolute)
+      if path.is_a?(Array)
+        first = absolute ? '/' : path.shift
+        path = path.inject(Pathname.new("#{first}")) do |pathname, segment|
+          pathname.join("#{segment}")
+        end
+        path
+      else
+        path = Pathname.for(path)
+        absolute ? path.expand_path : path
+      end
+    end
+  end
+
+  class Node
+    include Common
+    
+    attr_accessor :mtime
+    attr_accessor :ftype
+
+    def <=>(other)
+      self.mtime <=> other.mtime
+    end
+
+    def from_path(path)
+      path = absolute_path(path)
+      @mtime = path.mtime
+      @ftype = path.ftype
+    end
+
+    protected
+
+    def sanitize_key(key)
+      key_for_path(relative_path(key))
+    end
+  end
+
+  include Common
+  
+  def initialize
+    @mutex = Mutex.new
+    super
+  end
+
+  def clear
+    @mutex.lock
+    @children.clear
+    @mutex.unlock
+  end
+
+  def set(path)
+    unset(path)
+    node = descendant!(path)
+    node.from_path(path)
+    node.mtime
+  end
+
+  def unset(path='/')    
+    key = sanitize_key(path)
+
+    if key.empty?
+      self.clear
+      return nil
+    end
+    
+    segment = key.pop
+    node = descendant(key)
+
+    return unless node
+    
+    @mutex.lock
+    node.remove_child(segment)
+    @mutex.unlock    
+    
+    nil
+  end
+
+  def files
+    ftype('file')
+  end
+
+  def directories
+    ftype('directory')
+  end
+
+  protected
+  
+  def each(&block)
+    prefix='/'
+    super(prefix, &block)
+  end
+
+  def ftype(ft)
+    inject({}) do |hash, entry|
+      path, node = entry
+      hash["#{path}"] = node.mtime if node.ftype == ft
+      hash
+    end
+  end
+  
+  def descendant(path)
+    node = recurse_on_key(path, false)
+    node
+  end
+
+  def descendant!(path)
+    @mutex.lock
+    node = recurse_on_key(path, true)
+    @mutex.unlock
+    node
+  end
+
+  def sanitize_key(key)
+    key_for_path(absolute_path(key))
+  end
+end

data/lib/vendor/fssm/ext.rb

@@ -0,0 +1,37 @@
+class Pathname
+  class << self
+    def for(path)
+      path.is_a?(Pathname) ? path : new(path)
+    end
+  end
+  
+  # before overwriting chop_basename:
+  #   %total - 29.50%
+  #   %self - 20.50%
+  # after overwriting chop_basename:
+  #   %total - 24.36%
+  #   %self - 15.47%
+  CHOP_PAT = /\A#{SEPARATOR_PAT}?\z/
+  def chop_basename(path)
+    base = File.basename(path)
+    # the original version of this method recalculates this regexp
+    # each run, despite the pattern never changing.
+    if CHOP_PAT =~ base
+      return nil
+    else
+      return path[0, path.rindex(base)], base
+    end
+  end
+  
+  def segments
+    prefix, names = split_names(@path)
+    names.unshift(prefix) unless prefix.empty?
+    names.shift if names[0] == '.'
+    names
+  end
+  
+  def names
+    prefix, names = split_names(@path)
+    names
+  end
+end