haml 3.1.8 → 3.2.0.alpha.2

data/vendor/sass/vendor/fssm/Rakefile

@@ -1,11 +1,59 @@
 require 'rubygems'
-require 'bundler'
-Bundler::GemHelper.install_tasks
+require 'rake'
 
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.rspec_opts = ["--color", "--backtrace", "--format", "documentation"]
-  spec.verbose = true
+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 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

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

@@ -1,12 +1,9 @@
 $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
-# for rb-inotify/rb-fsevent
-require 'rubygems'
-
 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}" }
+  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

@@ -1,24 +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 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "fssm/version"
 
 Gem::Specification.new do |s|
-  s.name              = "fssm"
-  s.version           = FSSM::VERSION
-  s.platform          = Gem::Platform::RUBY
-  s.authors           = ["Travis Tilley", "Nathan Weizenbaum", "Chris Eppstein",
-                         "Jonathan Castello", "Tuomas Kareinen"]
-  s.email             = ["ttilley@gmail.com"]
-  s.homepage          = "https://github.com/ttilley/fssm"
-  s.summary           = %q{File System State Monitor}
-  s.description       = %q{The File System State Monitor keeps track of the state of any number of paths and will fire events when said state changes (create/update/delete). FSSM supports using FSEvents on MacOS, Inotify on GNU/Linux, and polling anywhere else.}
+  s.name = %q{fssm}
+  s.version = "0.1.4"
 
-  s.rubyforge_project = "fssm"
+  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"
+  ]
 
-  s.files             = `git ls-files`.split("\n")
-  s.test_files        = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables       = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths     = ["lib"]
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
 
-  s.add_development_dependency "rspec", ">= 2.4.0"
+    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

@@ -1,20 +1,17 @@
 dir = File.dirname(__FILE__)
 $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 
-#noinspection ALL
 module FSSM
   FileNotFoundError = Class.new(StandardError)
-  FileNotRealError  = Class.new(StandardError)
-  CallbackError     = Class.new(StandardError)
+  CallbackError = Class.new(StandardError)
 
   class << self
     def dbg(msg=nil)
-      STDERR.puts("FSSM -> #{msg}")
+      STDERR.puts(msg)
     end
 
     def monitor(*args, &block)
-      options = args[-1].is_a?(Hash) ? args.pop : {}
-      monitor = FSSM::Monitor.new(options)
+      monitor = FSSM::Monitor.new
       FSSM::Support.use_block(args.empty? ? monitor : monitor.path(*args), block)
 
       monitor.run
@@ -24,7 +21,6 @@ end
 
 require 'thread'
 
-require 'fssm/version'
 require 'fssm/pathname'
 require 'fssm/support'
 require 'fssm/tree'

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

@@ -10,7 +10,7 @@ module FSSM::Backends
     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|
+      fsevent = Rucola::FSEvents.new(handler.path.to_s, {:latency => 0.5}) do |events|
         events.each do |event|
           handler.refresh(event.path)
         end

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

@@ -5,8 +5,8 @@ module FSSM::Backends
     end
 
     def add_handler(handler, preload=true)
-      @notifier.watch(handler.path.to_s, :recursive, :attrib, :close_write, :create,
-                      :delete, :delete_self, :moved_from, :moved_to, :move_self) do |event|
+      @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)

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

@@ -2,7 +2,7 @@ module FSSM::Backends
   class Polling
     def initialize(options={})
       @handlers = []
-      @latency  = options[:latency] || 1.5
+      @latency = options[:latency] || 1.5
     end
 
     def add_handler(handler, preload=true)
@@ -14,7 +14,7 @@ module FSSM::Backends
       begin
         loop do
           start = Time.now.to_f
-          @handlers.each { |handler| handler.refresh }
+          @handlers.each {|handler| handler.refresh}
           nap_time = @latency - (Time.now.to_f - start)
           sleep nap_time if nap_time > 0
         end

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

@@ -14,7 +14,7 @@ module Rucola
       # 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
+        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.
@@ -88,22 +88,22 @@ module Rucola
       raise ArgumentError, 'No callback block was specified.' unless block_given?
 
       options = params.last.kind_of?(Hash) ? params.pop : {}
-      @paths  = params.flatten
+      @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
+      @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|
+      @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]) }
+        number_of_events.times {|i| events << Rucola::FSEvents::FSEvent.new(self, event_ids[i], paths_pointer[i]) }
         @user_callback.call(events)
       end
     end

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

@@ -4,33 +4,23 @@ class FSSM::Monitor
     @backend = FSSM::Backends::Default.new
   end
 
-  def path(path=nil, glob=nil, &block)
-    path = create_path(path, glob, &block)
-    @backend.add_handler(FSSM::State::Directory.new(path, @options))
+  def path(*args, &block)
+    path = FSSM::Path.new(*args)
+    FSSM::Support.use_block(path, block)
+
+    @backend.add_handler(FSSM::State::Directory.new(path))
     path
-  rescue FSSM::FileNotRealError => e
-    FSSM.dbg("#{e}")
-    nil
   end
 
-  def file(path=nil, glob=nil, &block)
-    path = create_path(path, glob, &block)
+  def file(*args, &block)
+    path = FSSM::Path.new(*args)
+    FSSM::Support.use_block(path, block)
+
     @backend.add_handler(FSSM::State::File.new(path))
     path
-  rescue FSSM::FileNotRealError => e
-    FSSM.dbg("#{e}")
-    nil
   end
 
   def run
     @backend.run
   end
-
-  private
-
-  def create_path(path, glob, &block)
-    path = FSSM::Path.new(path, glob, @options)
-    FSSM::Support.use_block(path, block)
-    path
-  end
 end

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

@@ -1,6 +1,5 @@
 class FSSM::Path
-  def initialize(path=nil, glob=nil, options={}, &block)
-    @options = options
+  def initialize(path=nil, glob=nil, &block)
     set_path(path || '.')
     set_glob(glob || '**/*')
     init_callbacks
@@ -27,32 +26,32 @@ class FSSM::Path
     set_glob(value)
   end
 
-  def create(*args, &block)
-    callback_action(:create, (block_given? ? block : args))
+  def create(callback_or_path=nil, &block)
+    callback_action(:create, (block_given? ? block : callback_or_path))
   end
 
-  def update(*args, &block)
-    callback_action(:update, (block_given? ? block : args))
+  def update(callback_or_path=nil, &block)
+    callback_action(:update, (block_given? ? block : callback_or_path))
   end
 
-  def delete(*args, &block)
-    callback_action(:delete, (block_given? ? block : args))
+  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|}
+    do_nothing = lambda {|base, relative|}
     @callbacks = Hash.new(do_nothing)
   end
 
-  def callback_action(type, args=[])
-    if args.is_a?(Proc)
-      set_callback(type, args)
-    elsif args.empty?
+  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, args)
+      run_callback(type, arg)
     end
   end
 
@@ -65,27 +64,25 @@ class FSSM::Path
     @callbacks[type]
   end
 
-  def run_callback(type, args)
-    callback_args = split_path(args[0])
-    callback_args << args[1] if @options[:directories]
+  def run_callback(type, arg)
+    base, relative = split_path(arg)
 
     begin
-      @callbacks[type].call(*callback_args)
+      @callbacks[type].call(base, relative)
     rescue Exception => e
-      raise FSSM::CallbackError, "#{type} - #{args[0]}: #{e.message}", e.backtrace
+      raise FSSM::CallbackError, "#{type} - #{base.join(relative)}: #{e.message}", e.backtrace
     end
   end
 
   def split_path(path)
     path = FSSM::Pathname.for(path)
-    [@path.to_s, (path.relative? ? path : path.relative_path_from(@path)).to_s]
+    [@path, (path.relative? ? path : path.relative_path_from(@path))]
   end
 
   def set_path(path)
-    @path = FSSM::Pathname.for(path).expand_path
-    raise FSSM::FileNotFoundError, "No such file or directory - #{@path}" unless @path.exist?
-    raise FSSM::FileNotRealError, "Path is virtual - #{@path}" if @path.is_virtual?
-    @path = @path.realpath
+    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)

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

@@ -1,36 +1,502 @@
 require 'fileutils'
 require 'find'
-require 'pathname'
 
 module FSSM
-  class Pathname < ::Pathname
-    VIRTUAL_REGEX = /^file:([^!]*)!/
+  class Pathname < String
+    SYMLOOP_MAX = 8
+
+    ROOT    = '/'.freeze
+    DOT     = '.'.freeze
+    DOT_DOT = '..'.freeze
 
     class << self
       def for(path)
-        path.is_a?(::FSSM::Pathname) ? path : new(path)
+        path.is_a?(::FSSM::Pathname) ? path : new("#{path}")
+      end
+    end
+
+    def initialize(path)
+      raise ArgumentError, "path cannot contain ASCII NULLs" if path =~ %r{\0}
+      super(path)
+    end
+
+    def <=>(other)
+      self.tr('/', "\0").to_s <=> other.to_str.tr('/', "\0")
+    rescue NoMethodError
+      nil
+    end
+
+    def ==(other)
+      left  =                  self.cleanpath.tr('/', "\0").to_s
+      right = self.class.for(other).cleanpath.tr('/', "\0").to_s
+
+      left == right
+    rescue NoMethodError
+      false
+    end
+
+    def +(path)
+      dup << path
+    end
+
+    def <<(path)
+      replace( join(path).cleanpath! )
+    end
+
+    def absolute?
+      self[0, 1].to_s == ROOT
+    end
+
+    def ascend
+      parts = to_a
+      parts.length.downto(1) do |i|
+        yield self.class.join(parts[0, i])
+      end
+    end
+
+    def children
+      entries[2..-1]
+    end
+
+    def cleanpath!
+      parts = to_a
+      final = []
+
+      parts.each do |part|
+        case part
+          when DOT     then
+            next
+          when DOT_DOT then
+            case final.last
+              when ROOT    then
+                next
+              when DOT_DOT then
+                final.push(DOT_DOT)
+              when nil     then
+                final.push(DOT_DOT)
+              else
+                final.pop
+            end
+          else
+            final.push(part)
+        end
+      end
+
+      replace(final.empty? ? DOT : self.class.join(*final))
+    end
+
+    def cleanpath
+      dup.cleanpath!
+    end
+
+    def descend
+      parts = to_a
+      1.upto(parts.length) { |i| yield self.class.join(parts[0, i]) }
+    end
+
+    def dot?
+      self == DOT
+    end
+
+    def dot_dot?
+      self == DOT_DOT
+    end
+
+    def each_filename(&blk)
+      to_a.each(&blk)
+    end
+
+    def mountpoint?
+      stat1 = self.lstat
+      stat2 = self.parent.lstat
+
+      stat1.dev != stat2.dev || stat1.ino == stat2.ino
+    rescue Errno::ENOENT
+      false
+    end
+
+    def parent
+      self + '..'
+    end
+
+    def realpath
+      path = self
+
+      SYMLOOP_MAX.times do
+        link = path.readlink
+        link = path.dirname + link if link.relative?
+        path = link
+      end
+
+      raise Errno::ELOOP, self
+    rescue Errno::EINVAL
+      path.expand_path
+    end
+
+    def relative?
+      !absolute?
+    end
+
+    def relative_path_from(base)
+      base = self.class.for(base)
+
+      raise ArgumentError, 'no relative path between a relative and absolute' if self.absolute? != base.absolute?
+
+      return self if base.dot?
+      return self.class.new(DOT) if self == base
+
+      base = base.cleanpath.to_a
+      dest = self.cleanpath.to_a
+
+      while !dest.empty? && !base.empty? && dest[0] == base[0]
+        base.shift
+        dest.shift
       end
 
-      alias :[] :glob
+      base.shift if base[0] == DOT
+      dest.shift if dest[0] == DOT
+
+      raise ArgumentError, "base directory may not contain '#{DOT_DOT}'" if base.include?(DOT_DOT)
+
+      path = base.fill(DOT_DOT) + dest
+      path = self.class.join(*path)
+      path = self.class.new(DOT) if path.empty?
+
+      path
     end
 
-    def is_virtual?
-      !!(VIRTUAL_REGEX =~ to_s)
+    def root?
+      !!(self =~ %r{^#{ROOT}+$})
     end
 
-    def segments
-      path  = to_s
-      array = path.split(File::SEPARATOR)
+    def to_a
+      array = to_s.split(File::SEPARATOR)
       array.delete('')
-      array.insert(0, File::SEPARATOR) if path[0, 1] == File::SEPARATOR
-      array[0] += File::SEPARATOR if path[0, 3] =~ SEPARATOR_PAT
+      array.insert(0, ROOT) if absolute?
       array
     end
 
+    alias segments to_a
+
+    def to_path
+      self
+    end
+
+    def to_s
+      "#{self}"
+    end
+
+    alias to_str to_s
+
+    def unlink
+      Dir.unlink(self)
+      true
+    rescue Errno::ENOTDIR
+      File.unlink(self)
+      true
+    end
+  end
+
+  class Pathname
+    def self.[](pattern)
+      Dir[pattern].map! {|d| FSSM::Pathname.new(d) }
+    end
+
+    def self.pwd
+      FSSM::Pathname.new(Dir.pwd)
+    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 self.glob(pattern, flags = 0)
+      dirs = Dir.glob(pattern, flags)
+      dirs.map! {|path| FSSM::Pathname.new(path) }
+
+      if block_given?
+        dirs.each {|dir| yield dir }
+        nil
+      else
+        dirs
+      end
+    end
+
     def glob(pattern, flags = 0, &block)
       patterns = [pattern].flatten
-      patterns.map! { |p| self.class.glob(to_s + p, flags, &block) }
+      patterns.map! {|p| self.class.glob(self.to_s + p, flags, &block) }
       patterns.flatten
     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
+  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
+    def self.join(*parts)
+      last_part = FSSM::Pathname.new(parts.last)
+      return last_part if last_part.absolute?
+      FSSM::Pathname.new(File.join(*parts.reject {|p| p.empty? }))
+    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 split
+      File.split(self).map {|part| FSSM::Pathname.new(part) }
+    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
+
+  class Pathname
+    class << self
+      alias getwd pwd
+    end
+
+    alias absolute expand_path
+    alias delete   unlink
+    alias exist?   exists?
+    alias fnmatch  fnmatch?
   end
 end