haml-edge 2.3.200 → 2.3.201

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

@@ -0,0 +1,502 @@
+require 'fileutils'
+require 'find'
+
+module FSSM
+  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}")
+      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
+
+      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 root?
+      !!(self =~ %r{^#{ROOT}+$})
+    end
+
+    def to_a
+      array = to_s.split(File::SEPARATOR)
+      array.delete('')
+      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(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

data/vendor/fssm/lib/fssm/state/directory.rb

@@ -0,0 +1,57 @@
+module FSSM::State
+  class Directory
+    attr_reader :path
+
+    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 = FSSM::Pathname.for(base)
+      previous = @cache.files
+      snapshot(base)
+      current = @cache.files
+      [previous, current]
+    end
+
+    def snapshot(base)
+      base = FSSM::Pathname.for(base)
+      @cache.unset(base)
+      @path.glob.each {|glob| add_glob(base, glob)}
+    end
+
+    def add_glob(base, glob)
+      FSSM::Pathname.glob(base.join(glob).to_s).each do |fn|
+        @cache.set(fn)
+      end
+    end
+
+  end
+end

data/vendor/fssm/lib/fssm/state/file.rb

@@ -0,0 +1,24 @@
+module FSSM::State
+  class File
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def refresh(base=nil, skip_callbacks=false)
+      base ||= @path.to_pathname
+      used_to_exist, @exists = @exists, base.exists?
+      # this handles bad symlinks without failing. why handle bad symlinks at
+      # all? well, we could still be interested in their creation and deletion.
+      old_mtime, @mtime = @mtime, base.symlink? ? Time.at(0) : base.mtime if @exists
+
+      unless skip_callbacks
+        @path.delete(@path.to_s) if used_to_exist && !@exists
+        @path.create(@path.to_s) if !used_to_exist && @exists
+        @path.update(@path.to_s) if used_to_exist && @exists && old_mtime != @mtime
+      end
+    end
+
+  end
+end

data/vendor/fssm/lib/fssm/support.rb

@@ -0,0 +1,63 @@
+require 'rbconfig'
+
+module FSSM::Support
+  class << self
+    def backend
+      @@backend ||= case
+        when mac? && !jruby? && carbon_core?
+          'FSEvents'
+        when linux? && rb_inotify?
+          'Inotify'
+        else
+          'Polling'
+      end
+    end
+
+    def jruby?
+      defined?(JRUBY_VERSION)
+    end
+
+    def mac?
+      Config::CONFIG['target_os'] =~ /darwin/i
+    end
+
+    def linux?
+      Config::CONFIG['target_os'] =~ /linux/i
+    end
+
+    def carbon_core?
+      begin
+        require 'osx/foundation'
+        OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+        true
+      rescue LoadError
+        STDERR.puts("Warning: Unable to load CarbonCore. FSEvents will be unavailable.")
+        false
+      end
+    end
+
+    def rb_inotify?
+      found = begin
+        require 'rb-inotify'
+        if defined?(INotify::VERSION)
+          version = INotify::VERSION
+          version[0] > 0 || version[1] >= 6
+        end
+      rescue LoadError
+        false
+      end
+      STDERR.puts("Warning: Unable to load rb-inotify >= 0.5.1. Inotify will be unavailable.") unless found
+      found
+    end
+
+    def use_block(context, block)
+      return if block.nil?
+      if block.arity == 1
+        block.call(context)
+      else
+        context.instance_eval(&block)
+      end
+    end
+
+  end
+end