compass 0.11.beta.7 → 0.11.0

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

@@ -1,57 +0,0 @@
-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/lib/vendor/fssm/fssm/state/file.rb

@@ -1,24 +0,0 @@
-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/lib/vendor/fssm/fssm/support.rb

@@ -1,63 +0,0 @@
-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

data/lib/vendor/fssm/fssm/tree.rb

@@ -1,176 +0,0 @@
-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 ?
-                FSSM::Pathname.for(prefix).join(segment) :
-                FSSM::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)
-      FSSM::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 = FSSM::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 = FSSM::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, (path, node)|
-        hash["#{path}"] = node.mtime if node.ftype == ft
-        hash
-      end
-    end
-  end
-
-end