compass 0.8.16

data/lib/vendor/fssm/fsevents.rb

@@ -0,0 +1,129 @@
+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/lib/vendor/fssm/monitor.rb

@@ -0,0 +1,25 @@
+class FSSM::Monitor
+  def initialize(options={})
+    @options = options
+    @backend = FSSM::Backends::Default.new
+  end
+
+  def path(*args, &block)
+    path = FSSM::Path.new(*args)
+
+    if block_given?
+      if block.arity == 1
+        block.call(path)
+      else
+        path.instance_eval(&block)
+      end
+    end
+
+    @backend.add_path(path)
+    path
+  end
+
+  def run
+    @backend.run
+  end
+end

data/lib/vendor/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 = Pathname.for(path)
+    [@path, (path.relative? ? path : path.relative_path_from(@path))]
+  end
+
+  def set_path(path)
+    path = Pathname.for(path)
+    raise FSSM::FileNotFoundError, "#{path}" unless path.exist?
+    @path = path.realpath
+  end
+
+  def set_glob(glob)
+    @glob = glob.is_a?(Array) ? glob : [glob]
+  end
+end

data/lib/vendor/fssm/state.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+class FSSM::State
+  def initialize(path)
+    @path = path
+    @cache = FSSM::Tree::Cache.new
+  end
+
+  def refresh(base=nil, skip_callbacks=false)
+    previous, current = recache(base || @path.to_pathname)
+
+    unless skip_callbacks
+      deleted(previous, current)
+      created(previous, current)
+      modified(previous, current)
+    end
+  end
+
+  private
+
+  def created(previous, current)
+    (current.keys - previous.keys).each {|created| @path.create(created)}
+  end
+
+  def deleted(previous, current)
+    (previous.keys - current.keys).each {|deleted| @path.delete(deleted)}
+  end
+
+  def modified(previous, current)
+    (current.keys & previous.keys).each do |file|
+      @path.update(file) if (current[file] <=> previous[file]) != 0
+    end
+  end
+
+  def recache(base)
+    base = Pathname.for(base)
+    previous = @cache.files
+    snapshot(base)
+    current = @cache.files
+    [previous, current]
+  end
+
+  def snapshot(base)
+    base = Pathname.for(base)
+    @cache.unset(base)
+    @path.glob.each {|glob| add_glob(base, glob)}
+  end
+
+  def add_glob(base, glob)
+    Pathname.glob(base.join(glob)).each do |fn|
+      @cache.set(fn)
+    end
+  end
+
+end

data/lib/vendor/fssm/support.rb

@@ -0,0 +1,22 @@
+module FSSM::Support
+  class << self
+    def backend
+      (mac? && carbon_core?) ? 'FSEvents' : 'Polling'
+    end
+
+    def mac?
+      @@mac ||= RUBY_PLATFORM =~ /darwin/i
+    end
+
+    def carbon_core?
+      @@carbon_core ||= begin
+        require 'osx/foundation'
+        OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+  end
+end

data/lib/vendor/fssm/tree.rb

@@ -0,0 +1,176 @@
+module FSSM::Tree
+  module NodeBase
+    def initialize
+      @children = {}
+    end
+    
+    protected
+    
+    def child(segment)
+      @children["#{segment}"]
+    end
+    
+    def child!(segment)
+      (@children["#{segment}"] ||= Node.new)
+    end
+    
+    def has_child?(segment)
+      @children.has_key?("#{segment}")
+    end
+    
+    def remove_child(segment)
+      @children.delete("#{segment}")
+    end
+    
+    def remove_children
+      @children.clear
+    end
+  end
+  
+  module NodeEnumerable
+    include NodeBase
+    include Enumerable
+    
+    def each(prefix=nil, &block)
+      @children.each do |segment, node|
+        cprefix = prefix ? 
+                  Pathname.for(prefix).join(segment) :
+                  Pathname.for(segment)
+        block.call(cprefix, node)
+        node.each(cprefix, &block)
+      end
+    end
+  end
+  
+  module NodeInsertion
+    include NodeBase
+    
+    def unset(path)
+      key = key_segments(path)
+      
+      if key.empty?
+        remove_children
+        return nil
+      end
+      
+      segment = key.pop
+      node = descendant(key)
+      
+      return unless node
+      
+      node.remove_child(segment)
+      
+      nil
+    end
+    
+    def set(path)
+      node = descendant!(path)
+      node.from_path(path).mtime
+    end
+    
+    protected
+    
+    def key_segments(key)
+      return key if key.is_a?(Array)
+      Pathname.for(key).segments
+    end
+    
+    def descendant(path)
+      recurse(path, false)
+    end
+    
+    def descendant!(path)
+      recurse(path, true)
+    end
+    
+    def recurse(key, create=false)
+      key = key_segments(key)
+      node = self
+      
+      until key.empty?
+        segment = key.shift
+        node = create ? node.child!(segment) : node.child(segment)
+        return nil unless node
+      end
+      
+      node
+    end
+  end
+  
+  module CacheDebug
+    def set(path)
+      FSSM.dbg("Cache#set(#{path})")
+      super
+    end
+    
+    def unset(path)
+      FSSM.dbg("Cache#unset(#{path})")
+      super
+    end
+    
+    def ftype(ft)
+      FSSM.dbg("Cache#ftype(#{ft})")
+      super
+    end
+  end
+  
+  class Node
+    include NodeBase
+    include NodeEnumerable
+    
+    attr_accessor :mtime
+    attr_accessor :ftype
+    
+    def <=>(other)
+      return unless other.is_a?(::FSSM::Tree::Node)
+      self.mtime <=> other.mtime
+    end
+    
+    def from_path(path)
+      path = Pathname.for(path)
+      @ftype = path.ftype
+      # this handles bad symlinks without failing. why handle bad symlinks at
+      # all? well, we could still be interested in their creation and deletion.
+      @mtime = path.symlink? ? Time.at(0) : path.mtime
+      self
+    end
+  end
+  
+  class Cache
+    include NodeBase
+    include NodeEnumerable
+    include NodeInsertion
+    include CacheDebug if $DEBUG
+    
+    def set(path)
+      # all paths set from this level need to be absolute
+      # realpath will fail on broken links
+      path = Pathname.for(path).expand_path      
+      super(path)
+    end
+    
+    def files
+      ftype('file')
+    end
+    
+    def directories
+      ftype('directory')
+    end
+    
+    def links
+      ftype('link')
+    end
+    alias symlinks links
+    
+    private
+    
+    def ftype(ft)
+      inject({}) do |hash, entry|
+        path, node = entry
+        hash["#{path}"] = node.mtime if node.ftype == ft
+        hash
+      end
+    end
+  end
+  
+end