sass 3.1.4 → 3.1.5

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

@@ -4,23 +4,33 @@ class FSSM::Monitor
     @backend = FSSM::Backends::Default.new
   end
 
-  def path(*args, &block)
-    path = FSSM::Path.new(*args)
-    FSSM::Support.use_block(path, block)
-
-    @backend.add_handler(FSSM::State::Directory.new(path))
+  def path(path=nil, glob=nil, &block)
+    path = create_path(path, glob, &block)
+    @backend.add_handler(FSSM::State::Directory.new(path, @options))
     path
+  rescue FSSM::FileNotRealError => e
+    FSSM.dbg("#{e}")
+    nil
   end
 
-  def file(*args, &block)
-    path = FSSM::Path.new(*args)
-    FSSM::Support.use_block(path, block)
-
+  def file(path=nil, glob=nil, &block)
+    path = create_path(path, glob, &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/fssm/lib/fssm/path.rb

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

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

@@ -1,502 +1,36 @@
 require 'fileutils'
 require 'find'
+require 'pathname'
 
 module FSSM
-  class Pathname < String
-    SYMLOOP_MAX = 8
-
-    ROOT    = '/'.freeze
-    DOT     = '.'.freeze
-    DOT_DOT = '..'.freeze
+  class Pathname < ::Pathname
+    VIRTUAL_REGEX = /^file:([^!]*)!/
 
     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
+        path.is_a?(::FSSM::Pathname) ? path : new(path)
       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
+      alias :[] :glob
     end
 
-    def root?
-      !!(self =~ %r{^#{ROOT}+$})
+    def is_virtual?
+      !!(VIRTUAL_REGEX =~ to_s)
     end
 
-    def to_a
-      array = to_s.split(File::SEPARATOR)
+    def segments
+      path  = to_s
+      array = path.split(File::SEPARATOR)
       array.delete('')
-      array.insert(0, ROOT) if absolute?
+      array.insert(0, File::SEPARATOR) if path[0, 1] == File::SEPARATOR
+      array[0] += File::SEPARATOR if path[0, 3] =~ SEPARATOR_PAT
       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.map! { |p| self.class.glob(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