ttilley-fssm 0.0.6

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+nbproject
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Travis Tilley
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,55 @@
+Monitor API
+===========
+
+There are three ways you can run the monitor.
+
+1. call monitor with a path parameter, and define callbacks in a block
+2. call monitor with a block to configure multiple paths and callbacks
+3. create a monitor object and run each step manually
+
+Monitor with path
+-----------------
+
+This form watches one path, and enters the run loop automatically. The first parameter is the path to watch, and the second parameter is an optional glob pattern or array of glob patterns that a file must match in order to trigger a callback. The default glob, if ommitted, is `'**/*'`.
+
+	FSSM.monitor('/some/directory/', '**/*') do
+	  update {|base, relative|}
+	  delete {|base, relative|}
+	  create {|base, relative|}
+	end
+
+Monitor with block
+------------------
+
+This form watches one or more paths, and enters the run loop automatically. The glob configuration call can be ommitted, and defaults to `'**/*'`.
+
+	FSSM.monitor do
+	  path '/some/directory/' do
+	    glob '**/*.yml'
+   
+	    update {|base, relative|}
+	    delete {|base, relative|}
+	    create {|base, relative|}
+	  end
+ 
+	  path '/some/other/directory/' do
+	    update {|base, relative|}
+	    delete {|base, relative|}
+	    create {|base, relative|}
+	  end
+	end
+
+Monitor object
+--------------
+
+This form doesn't enter the run loop automatically.
+
+	monitor = FSSM::Monitor.new
+
+	monitor.path '/some/directory/' do
+	  update {|base, relative|}
+	  delete {|base, relative|}
+	  create {|base, relative|}
+	end
+
+	monitor.run

data/Rakefile

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fssm"
+    gem.summary = %Q{file system state monitor}
+    gem.description = %Q{file system state monitor}
+    gem.email = "ttilley@gmail.com"
+    gem.homepage = "http://github.com/ttilley/fssm"
+    gem.authors = ["Travis Tilley"]
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "yard"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'reek/rake_task'
+  Reek::RakeTask.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+begin
+  require 'roodi'
+  require 'roodi_task'
+  RoodiTask.new do |t|
+    t.verbose = false
+  end
+rescue LoadError
+  task :roodi do
+    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
+  end
+end
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 6
+:major: 0

data/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/fssm.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fssm}
+  s.version = "0.0.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Travis Tilley"]
+  s.date = %q{2009-09-05}
+  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/polling.rb",
+     "lib/fssm/ext.rb",
+     "lib/fssm/fsevents.rb",
+     "lib/fssm/monitor.rb",
+     "lib/fssm/path.rb",
+     "lib/fssm/state.rb",
+     "lib/fssm/support.rb",
+     "lib/fssm/tree.rb",
+     "prof-cache.rb",
+     "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.5}
+  s.summary = %q{file system state monitor}
+  s.test_files = [
+    "spec/path_spec.rb",
+     "spec/root/file.rb",
+     "spec/spec_helper.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"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end

data/lib/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/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/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

data/lib/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/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/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/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/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/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

data/lib/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/prof-cache.rb

@@ -0,0 +1,40 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'fssm'
+
+require 'rubygems'
+require 'ruby-prof'
+
+$test_path = Pathname.new('.')
+$test_files = Pathname.glob(File.join($test_path, '**', '*'))
+
+RubyProf.start
+RubyProf.pause
+
+cache = FSSM::Tree::Cache.new
+
+5000.times do |num|
+  iteration = "%-5d" % (num + 1)
+  print "iteration #{iteration}"
+  
+  print '!'
+  RubyProf.resume
+  cache.unset($test_path)
+  RubyProf.pause
+  print '!'
+
+  $test_files.each do |fn|
+    print '.'
+    RubyProf.resume
+    cache.set(fn)
+    RubyProf.pause
+  end
+  
+  print "\n\n"
+end
+
+result = RubyProf.stop
+output = File.new('prof.html', 'w+')
+
+printer = RubyProf::GraphHtmlPrinter.new(result)
+printer.print(output, :min_percent => 1)

data/spec/path_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "The File System State Monitor" do
+  describe "paths" do
+    it "should accept a valid filesystem directory" do
+      lambda {FSSM::Path.new("#{@watch_root}")}.should_not raise_error
+    end
+
+    it "should not accept an invalid filesystem directory" do
+      lambda {FSSM::Path.new('/does/not/exist/kthxbye')}.should raise_error
+    end
+
+    it "should default the path to the current directory" do
+      path = FSSM::Path.new
+      here = Pathname.new('.').realpath
+
+      "#{here}".should == "#{path}"
+    end
+
+    it "should accept an optional glob array parameter" do
+      path = FSSM::Path.new('.', ['**/*.yml'])
+      path.glob.should == ['**/*.yml']
+    end
+
+    it "should accept an optional glob string parameter" do
+      path = FSSM::Path.new('.', '**/*.yml')
+      path.glob.should == ['**/*.yml']
+    end
+
+    it "should default the glob to ['**/*']" do
+      path = FSSM::Path.new
+      path.glob.should == ['**/*']
+    end
+
+    it "should accept a callback for update events" do
+      path = FSSM::Path.new
+      callback = lambda {|base, relative| return true}
+      path.update(callback)
+      (path.update).should == callback
+    end
+
+    it "should accept a callback for delete events" do
+      path = FSSM::Path.new
+      callback = lambda {|base, relative| return true}
+      path.delete(callback)
+      (path.delete).should == callback
+    end
+
+    it "should accept a callback for create events" do
+      path = FSSM::Path.new
+      callback = lambda {|base, relative| return true}
+      path.create(callback)
+      (path.create).should == callback
+    end
+
+    it "should accept a configuration block" do
+      path = FSSM::Path.new "#{@watch_root}" do
+        glob '**/*.yml'
+        update {|base, relative| 'success'}
+        delete {|base, relative| 'success'}
+        create {|base, relative| 'success'}
+      end
+
+      "#{path}".should == "#{@watch_root}"
+      path.glob.should == ['**/*.yml']
+      path.update.should be_a_kind_of(Proc)
+      path.delete.should be_a_kind_of(Proc)
+      path.create.should be_a_kind_of(Proc)
+      path.update.call('','').should == 'success'
+      path.delete.call('','').should == 'success'
+      path.create.call('','').should == 'success'
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'pathname'
+require 'fssm'
+
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  config.before :all do
+    @watch_root = Pathname.new(__FILE__).dirname.join('root').expand_path
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: ttilley-fssm
+version: !ruby/object:Gem::Version 
+  version: 0.0.6
+platform: ruby
+authors: 
+- Travis Tilley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-05 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: file system state monitor
+email: ttilley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION.yml
+- example.rb
+- fssm.gemspec
+- lib/fssm.rb
+- lib/fssm/backends/fsevents.rb
+- lib/fssm/backends/polling.rb
+- lib/fssm/ext.rb
+- lib/fssm/fsevents.rb
+- lib/fssm/monitor.rb
+- lib/fssm/path.rb
+- lib/fssm/state.rb
+- lib/fssm/support.rb
+- lib/fssm/tree.rb
+- prof-cache.rb
+- 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
+has_rdoc: false
+homepage: http://github.com/ttilley/fssm
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: file system state monitor
+test_files: 
+- spec/path_spec.rb
+- spec/root/file.rb
+- spec/spec_helper.rb