fssm 0.0.8

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 = 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, "#{path}" unless path.exist?
+    @path = path.expand_path
+  end
+
+  def set_glob(glob)
+    @glob = glob.is_a?(Array) ? glob : [glob]
+  end
+end

data/lib/fssm/pathname.rb

@@ -0,0 +1,350 @@
+# The bundled ruby pathname library is a slow and hideous beast.
+# There. I said it. This version is based on pathname3.
+
+module FSSM
+  class Pathname < String
+    
+    SEPARATOR = Regexp.quote(File::SEPARATOR)
+    
+    if File::ALT_SEPARATOR
+      ALT_SEPARATOR = Regexp.quote(File::ALT_SEPARATOR)
+      SEPARATOR_PAT = Regexp.compile("[#{SEPARATOR}#{ALT_SEPARATOR}]")
+    else
+      SEPARATOR_PAT = Regexp.compile(SEPARATOR)
+    end
+    
+    if RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/
+      PREFIX_PAT = Regexp.compile("^([A-Za-z]:#{SEPARATOR_PAT})")
+    else
+      PREFIX_PAT = Regexp.compile("^(#{SEPARATOR_PAT})")
+    end
+
+    class << self
+      def for(path)
+        path = path.is_a?(::FSSM::Pathname) ? path : new(path)
+        path.dememo
+        path
+      end
+    end
+    
+    def initialize(path)
+      if path =~ %r{\0}
+        raise ArgumentError, "path cannot contain ASCII NULLs"
+      end
+      
+      dememo
+      
+      super(path)
+    end
+    
+    def to_path
+      self
+    end
+    
+    def to_s
+      "#{self}"
+    end
+    alias to_str to_s
+    
+    def to_a      
+      return @segments if @segments
+      set_prefix_and_names
+      @segments = @names.dup
+      @segments.delete('.')
+      @segments.unshift(@prefix) unless @prefix.empty?
+      @segments
+    end
+    alias segments to_a
+    
+    def each_filename(&block)
+      to_a.each(&block)
+    end
+    
+    def ascend
+      parts = to_a
+      parts.length.downto(1) do |i|
+        yield self.class.join(parts[0, i])
+      end
+    end
+    
+    def descend
+      parts = to_a
+      1.upto(parts.length) do |i|
+        yield self.class.join(parts[0, i])
+      end
+    end
+    
+    def root?
+      set_prefix_and_names
+      @names.empty? && !@prefix.empty?
+    end
+    
+    def parent
+      self + '..'
+    end
+    
+    def relative?
+      set_prefix_and_names
+      @prefix.empty?
+    end
+    
+    def absolute?
+      !relative?
+    end
+    
+    def +(path)
+      dup << path
+    end
+    
+    def <<(path)
+      replace(join(path).cleanpath!)
+    end
+    
+    def cleanpath!
+      parts = to_a
+      final = []
+
+      parts.each do |part|
+        case part
+          when '.'          then next
+          when '..'         then
+            case final.last
+              when '..'     then final.push('..')
+              when nil      then final.push('..')
+              else          final.pop
+            end
+          else final.push(part)
+        end
+      end
+
+      replace(final.empty? ? Dir.pwd : File.join(*final))
+    end
+    
+    def cleanpath
+      dup.cleanpath!
+    end
+    
+    def realpath
+       raise unless self.exist?
+
+       if File.symlink?(self)
+          file = self.dup
+
+          while true
+             file = File.join(File.dirname(file), File.readlink(file))
+             break unless File.symlink?(file)
+          end
+
+          self.class.new(file).clean
+       else
+          self.class.new(Dir.pwd) + self
+       end
+    end
+    
+    def relative_path_from(base)
+      base = self.class.for(base)
+      
+      if self.absolute? != base.absolute?
+        raise ArgumentError, 'no relative path between a relative and absolute'
+      end
+      
+      if self.prefix != base.prefix
+        raise ArgumentError, "different prefix: #{@prefix.inspect} and #{base.prefix.inspect}"
+      end
+      
+      base = base.cleanpath!.segments
+      dest = dup.cleanpath!.segments
+      
+      while !dest.empty? && !base.empty? && dest[0] == base[0]
+        base.shift
+        dest.shift
+      end
+      
+      base.shift if base[0] == '.'
+      dest.shift if dest[0] == '.'
+      
+      if base.include?('..')
+        raise ArgumentError, "base directory may not contain '..'"
+      end
+      
+      path = base.fill('..') + dest
+      path = self.class.join(*path)
+      path = self.class.new('.') if path.empty?
+      
+      path
+    end
+    
+    def replace(path)      
+      if path =~ %r{\0}
+        raise ArgumentError, "path cannot contain ASCII NULLs"
+      end
+      
+      dememo
+      
+      super(path)
+    end
+    
+    def unlink
+      Dir.unlink(self)
+      true
+    rescue Errno::ENOTDIR
+      File.unlink(self)
+      true
+    end
+    
+    def prefix
+      set_prefix_and_names
+      @prefix
+    end
+    
+    def names
+      set_prefix_and_names
+      @names
+    end
+    
+    def dememo
+      @set        = nil
+      @segments   = nil
+      @prefix     = nil
+      @names      = nil
+    end
+    
+    private
+    
+    def set_prefix_and_names
+      return if @set
+      
+      @names = []
+      
+      if (match = PREFIX_PAT.match(self))
+        @prefix = match[0].to_s
+        @names += match.post_match.split(SEPARATOR_PAT)
+      else
+        @prefix = ''
+        @names += self.split(SEPARATOR_PAT)
+      end
+      
+      @names.compact!
+      @names.delete('')
+      
+      @set = true
+    end
+
+  end
+
+  class Pathname
+    class << self
+      def glob(pattern, flags=0)
+        dirs = Dir.glob(pattern, flags)
+        dirs.map! {|path| new(path)}
+        
+        if block_given?
+          dirs.each {|dir| yield dir}
+          nil
+        else
+          dirs
+        end
+      end
+      
+      def [](pattern)
+        Dir[pattern].map! {|path| new(path)}
+      end
+      
+      def pwd
+        new(Dir.pwd)
+      end
+    end
+    
+    def entries; Dir.entries(self).map! {|e| FSSM::Pathname.new(e) }; end
+    def mkdir(mode = 0777); Dir.mkdir(self, mode); end
+    def opendir(&blk); Dir.open(self, &blk); end
+    def rmdir; Dir.rmdir(self); end
+
+    def chdir 
+      blk = lambda { yield self } if block_given?
+      Dir.chdir(self, &blk)
+    end
+  end
+
+  class Pathname
+    def blockdev?; FileTest.blockdev?(self); end
+    def chardev?; FileTest.chardev?(self); end
+    def directory?; FileTest.directory?(self); end
+    def executable?; FileTest.executable?(self); end
+    def executable_real?; FileTest.executable_real?(self); end
+    def exists?; FileTest.exists?(self); end
+    def file?; FileTest.file?(self); end
+    def grpowned?; FileTest.grpowned?(self); end
+    def owned?; FileTest.owned?(self); end
+    def pipe?; FileTest.pipe?(self); end
+    def readable?; FileTest.readable?(self); end
+    def readable_real?; FileTest.readable_real?(self); end
+    def setgid?; FileTest.setgit?(self); end
+    def setuid?; FileTest.setuid?(self); end
+    def socket?; FileTest.socket?(self); end
+    def sticky?; FileTest.sticky?(self); end
+    def symlink?; FileTest.symlink?(self); end
+    def world_readable?; FileTest.world_readable?(self); end
+    def world_writable?; FileTest.world_writable?(self); end
+    def writable?; FileTest.writable?(self); end
+    def writable_real?; FileTest.writable_real?(self); end
+    def zero?; FileTest.zero?(self); end
+    
+    alias exist? exists?
+  end
+
+  class Pathname
+    def atime; File.atime(self); end
+    def ctime; File.ctime(self); end
+    def ftype; File.ftype(self); end
+    def lstat; File.lstat(self); end
+    def mtime; File.mtime(self); end
+    def stat; File.stat(self); end
+    def utime(atime, mtime); File.utime(self, atime, mtime); end
+  end
+
+  class Pathname
+    class << self
+      def join(*parts)
+        new(File.join(*parts.reject {|p| p.empty? }))
+      end
+    end
+    
+    def basename; self.class.new(File.basename(self)); end
+    def chmod(mode); File.chmod(mode, self); end
+    def chown(owner, group); File.chown(owner, group, self); end
+    def dirname; self.class.new(File.dirname(self)); end
+    def expand_path(from = nil); self.class.new(File.expand_path(self, from)); end
+    def extname; File.extname(self); end
+    def fnmatch?(pat, flags = 0); File.fnmatch(pat, self, flags); end
+    def join(*parts); self.class.join(self, *parts); end
+    def lchmod(mode); File.lchmod(mode, self); end
+    def lchown(owner, group); File.lchown(owner, group, self); end
+    def link(to); File.link(self, to); end
+    def open(mode = 'r', perm = nil, &blk); File.open(self, mode, perm, &blk); end
+    def readlink; self.class.new(File.readlink(self)); end
+    def rename(to); File.rename(self, to); replace(to); end
+    def size; File.size(self); end
+    def size?; File.size?(self); end
+    def symlink(to); File.symlink(self, to); end
+    def truncate; File.truncate(self); end
+  end
+
+  class Pathname
+    def mkpath; self.class.new(FileUtils.mkpath(self)); end
+    def rmtree; self.class.new(FileUtils.rmtree(self).first); end
+    def touch; self.class.new(FileUtils.touch(self).first); end
+  end
+
+  class Pathname
+    def each_line(sep = $/, &blk); IO.foreach(self, sep, &blk); end
+    def read(len = nil, off = 0); IO.read(self, len, off); end
+    def readlines(sep = $/); IO.readlines(self, sep); end
+    def sysopen(mode = 'r', perm = nil); IO.sysopen(self, mode, perm); end
+  end
+
+  class Pathname
+    def find; Find.find(self) {|path| yield FSSM::Pathname.new(path) }; end
+  end
+
+end