haml 3.1.0.alpha.14 → 3.1.0.alpha.17

data/vendor/sass/vendor/fssm/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 4
+:build: 

data/vendor/sass/vendor/fssm/example.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'fssm'
+
+FSSM.monitor('.', '**/*') do
+  update {|b, r| puts "Update in #{b} to #{r}"}
+  delete {|b, r| puts "Delete in #{b} to #{r}"}
+  create {|b, r| puts "Create in #{b} to #{r}"}
+end

data/vendor/sass/vendor/fssm/fssm.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fssm}
+  s.version = "0.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Travis Tilley"]
+  s.date = %q{2010-03-10}
+  s.description = %q{file system state monitor}
+  s.email = %q{ttilley@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION.yml",
+     "example.rb",
+     "fssm.gemspec",
+     "lib/fssm.rb",
+     "lib/fssm/backends/fsevents.rb",
+     "lib/fssm/backends/inotify.rb",
+     "lib/fssm/backends/polling.rb",
+     "lib/fssm/backends/rubycocoa/fsevents.rb",
+     "lib/fssm/monitor.rb",
+     "lib/fssm/path.rb",
+     "lib/fssm/pathname.rb",
+     "lib/fssm/state/directory.rb",
+     "lib/fssm/state/file.rb",
+     "lib/fssm/support.rb",
+     "lib/fssm/tree.rb",
+     "profile/prof-cache.rb",
+     "profile/prof-fssm-pathname.html",
+     "profile/prof-pathname.rb",
+     "profile/prof-plain-pathname.html",
+     "profile/prof.html",
+     "spec/path_spec.rb",
+     "spec/root/duck/quack.txt",
+     "spec/root/file.css",
+     "spec/root/file.rb",
+     "spec/root/file.yml",
+     "spec/root/moo/cow.txt",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ttilley/fssm}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{file system state monitor}
+  s.test_files = [
+    "spec/path_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/root/file.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/vendor/sass/vendor/fssm/lib/fssm.rb

@@ -0,0 +1,33 @@
+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
+      FSSM::Support.use_block(args.empty? ? monitor : monitor.path(*args), block)
+
+      monitor.run
+    end
+  end
+end
+
+require 'thread'
+
+require 'fssm/pathname'
+require 'fssm/support'
+require 'fssm/tree'
+require 'fssm/path'
+require 'fssm/state/directory'
+require 'fssm/state/file'
+require 'fssm/monitor'
+
+require "fssm/backends/#{FSSM::Support.backend.downcase}"
+FSSM::Backends::Default = FSSM::Backends.const_get(FSSM::Support.backend)

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

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'rubycocoa/fsevents')
+
+module FSSM::Backends
+  class FSEvents
+    def initialize
+      @handlers = {}
+      @fsevents = []
+    end
+
+    def add_handler(handler, preload=true)
+      @handlers[handler.path.to_s] = handler
+
+      fsevent = Rucola::FSEvents.new(handler.path.to_s, {:latency => 0.5}) do |events|
+        events.each do |event|
+          handler.refresh(event.path)
+        end
+      end
+
+      fsevent.create_stream
+      handler.refresh(nil, 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/vendor/sass/vendor/fssm/lib/fssm/backends/inotify.rb

@@ -0,0 +1,26 @@
+module FSSM::Backends
+  class Inotify
+    def initialize
+      @notifier = INotify::Notifier.new
+    end
+
+    def add_handler(handler, preload=true)
+      @notifier.watch(handler.path.to_s, :recursive, :attrib, :modify, :create,
+        :delete, :delete_self, :moved_from, :moved_to, :move_self) do |event|
+        path = FSSM::Pathname.for(event.absolute_name)
+        path = path.dirname unless event.name == "" # Event on root directory
+        handler.refresh(path)
+      end
+
+      handler.refresh(nil, true) if preload
+    end
+
+    def run
+      begin
+        @notifier.run
+      rescue Interrupt
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+module FSSM::Backends
+  class Polling
+    def initialize(options={})
+      @handlers = []
+      @latency = options[:latency] || 1.5
+    end
+
+    def add_handler(handler, preload=true)
+      handler.refresh(nil, 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/vendor/sass/vendor/fssm/lib/fssm/backends/rubycocoa/fsevents.rb

@@ -0,0 +1,131 @@
+OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+
+module Rucola
+  class FSEvents
+    class FSEvent
+      attr_reader :fsevents_object
+      attr_reader :id
+      attr_reader :path
+
+      def initialize(fsevents_object, id, path)
+        @fsevents_object, @id, @path = fsevents_object, id, path
+      end
+
+      # Returns an array of the files/dirs in the path that the event occurred in.
+      # The files are sorted by the modification time, the first entry is the last modified file.
+      def files
+        Dir.glob("#{File.expand_path(path)}/*").sort_by {|f| File.mtime(f) }.reverse
+      end
+
+      # Returns the last modified file in the path that the event occurred in.
+      def last_modified_file
+        files.first
+      end
+    end
+
+    class StreamError < StandardError;
+    end
+
+    attr_reader :paths
+    attr_reader :stream
+
+    attr_accessor :allocator
+    attr_accessor :context
+    attr_accessor :since
+    attr_accessor :latency
+    attr_accessor :flags
+
+    # Initializes a new FSEvents `watchdog` object and starts watching the directories you specify for events. The
+    # block is used as a handler for events, which are passed as the block's argument. This method is the easiest
+    # way to start watching some directories if you don't care about the details of setting up the event stream.
+    #
+    #   Rucola::FSEvents.start_watching('/tmp') do |events|
+    #     events.each { |event| log.debug("#{event.files.inspect} were changed.") }
+    #   end
+    #   
+    #   Rucola::FSEvents.start_watching('/var/log/system.log', '/var/log/secure.log', :since => last_id, :latency => 5) do
+    #     Growl.notify("Something was added to your log files!")
+    #   end
+    #
+    # Note that the method also returns the FSEvents object. This enables you to control the event stream if you want to.
+    #
+    #   fsevents = Rucola::FSEvents.start_watching('/Volumes') do |events|
+    #     events.each { |event| Growl.notify("Volume changes: #{event.files.to_sentence}") }
+    #   end
+    #   fsevents.stop
+    def self.start_watching(*params, &block)
+      fsevents = new(*params, &block)
+      fsevents.create_stream
+      fsevents.start
+      fsevents
+    end
+
+    # Creates a new FSEvents `watchdog` object. You can specify a list of paths to watch and options to control the
+    # behaviour of the watchdog. The block you pass serves as a callback when an event is generated on one of the
+    # specified paths.
+    #
+    #   fsevents = FSEvents.new('/etc/passwd') { Mailer.send_mail("Someone touched the password file!") }
+    #   fsevents.create_stream
+    #   fsevents.start
+    #
+    #   fsevents = FSEvents.new('/home/upload', :since => UploadWatcher.last_event_id) do |events|
+    #     events.each do |event|
+    #       UploadWatcher.last_event_id = event.id
+    #       event.files.each do |file|
+    #         UploadWatcher.logfile.append("#{file} was changed")
+    #       end
+    #     end
+    #   end
+    #
+    # *:since: The service will report events that have happened after the supplied event ID. Never use 0 because that 
+    #   will cause every fsevent since the "beginning of time" to be reported. Use OSX::KFSEventStreamEventIdSinceNow
+    #   if you want to receive events that have happened after this call. (Default: OSX::KFSEventStreamEventIdSinceNow).
+    #   You can find the ID's passed with :since in the events passed to your block.
+    # *:latency: Number of seconds to wait until an FSEvent is reported, this allows the service to bundle events. (Default: 0.0)
+    #
+    # Please refer to the Cocoa documentation for the rest of the options.
+    def initialize(*params, &block)
+      raise ArgumentError, 'No callback block was specified.' unless block_given?
+
+      options = params.last.kind_of?(Hash) ? params.pop : {}
+      @paths = params.flatten
+
+      paths.each { |path| raise ArgumentError, "The specified path (#{path}) does not exist." unless File.exist?(path) }
+
+      @allocator = options[:allocator] || OSX::KCFAllocatorDefault
+      @context = options[:context] || nil
+      @since = options[:since] || OSX::KFSEventStreamEventIdSinceNow
+      @latency = options[:latency] || 0.0
+      @flags = options[:flags] || 0
+      @stream = options[:stream] || nil
+
+      @user_callback = block
+      @callback = Proc.new do |stream, client_callback_info, number_of_events, paths_pointer, event_flags, event_ids|
+        paths_pointer.regard_as('*')
+        events = []
+        number_of_events.times {|i| events << Rucola::FSEvents::FSEvent.new(self, event_ids[i], paths_pointer[i]) }
+        @user_callback.call(events)
+      end
+    end
+
+    # Create the stream.
+    # Raises a Rucola::FSEvents::StreamError if the stream could not be created.
+    def create_stream
+      @stream = OSX.FSEventStreamCreate(@allocator, @callback, @context, @paths, @since, @latency, @flags)
+      raise(StreamError, 'Unable to create FSEvents stream.') unless @stream
+      OSX.FSEventStreamScheduleWithRunLoop(@stream, OSX.CFRunLoopGetCurrent, OSX::KCFRunLoopDefaultMode)
+    end
+
+    # Start the stream.
+    # Raises a Rucola::FSEvents::StreamError if the stream could not be started.
+    def start
+      raise(StreamError, 'Unable to start FSEvents stream.') unless OSX.FSEventStreamStart(@stream)
+    end
+
+    # Stop the stream.
+    # You can resume it by calling `start` again.
+    def stop
+      OSX.FSEventStreamStop(@stream)
+    end
+  end
+end

data/vendor/sass/vendor/fssm/lib/fssm/monitor.rb

@@ -0,0 +1,26 @@
+class FSSM::Monitor
+  def initialize(options={})
+    @options = options
+    @backend = FSSM::Backends::Default.new
+  end
+
+  def path(*args, &block)
+    path = FSSM::Path.new(*args)
+    FSSM::Support.use_block(path, block)
+
+    @backend.add_handler(FSSM::State::Directory.new(path))
+    path
+  end
+
+  def file(*args, &block)
+    path = FSSM::Path.new(*args)
+    FSSM::Support.use_block(path, block)
+
+    @backend.add_handler(FSSM::State::File.new(path))
+    path
+  end
+
+  def run
+    @backend.run
+  end
+end

data/vendor/sass/vendor/fssm/lib/fssm/path.rb

@@ -0,0 +1,91 @@
+class FSSM::Path
+  def initialize(path=nil, glob=nil, &block)
+    set_path(path || '.')
+    set_glob(glob || '**/*')
+    init_callbacks
+
+    if block_given?
+      if block.arity == 1
+        block.call(self)
+      else
+        self.instance_eval(&block)
+      end
+    end
+  end
+
+  def to_s
+    @path.to_s
+  end
+
+  def to_pathname
+    @path
+  end
+
+  def glob(value=nil)
+    return @glob if value.nil?
+    set_glob(value)
+  end
+
+  def create(callback_or_path=nil, &block)
+    callback_action(:create, (block_given? ? block : callback_or_path))
+  end
+
+  def update(callback_or_path=nil, &block)
+    callback_action(:update, (block_given? ? block : callback_or_path))
+  end
+
+  def delete(callback_or_path=nil, &block)
+    callback_action(:delete, (block_given? ? block : callback_or_path))
+  end
+
+  private
+
+  def init_callbacks
+    do_nothing = lambda {|base, relative|}
+    @callbacks = Hash.new(do_nothing)
+  end
+
+  def callback_action(type, arg=nil)
+    if arg.is_a?(Proc)
+      set_callback(type, arg)
+    elsif arg.nil?
+      get_callback(type)
+    else
+      run_callback(type, arg)
+    end
+  end
+
+  def set_callback(type, arg)
+    raise ArgumentError, "Proc expected" unless arg.is_a?(Proc)
+    @callbacks[type] = arg
+  end
+
+  def get_callback(type)
+    @callbacks[type]
+  end
+
+  def run_callback(type, arg)
+    base, relative = split_path(arg)
+
+    begin
+      @callbacks[type].call(base, relative)
+    rescue Exception => e
+      raise FSSM::CallbackError, "#{type} - #{base.join(relative)}: #{e.message}", e.backtrace
+    end
+  end
+
+  def split_path(path)
+    path = FSSM::Pathname.for(path)
+    [@path, (path.relative? ? path : path.relative_path_from(@path))]
+  end
+
+  def set_path(path)
+    path = FSSM::Pathname.for(path)
+    raise FSSM::FileNotFoundError, "No such file or directory - #{path}" unless path.exist?
+    @path = path.expand_path
+  end
+
+  def set_glob(glob)
+    @glob = glob.is_a?(Array) ? glob : [glob]
+  end
+end