haml 3.2.0.alpha.10 → 3.2.0.alpha.13

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

@@ -1,36 +0,0 @@
-class FSSM::Monitor
-  def initialize(options={})
-    @options = options
-    @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))
-    path
-  rescue FSSM::FileNotRealError => e
-    FSSM.dbg("#{e}")
-    nil
-  end
-
-  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/sass/vendor/fssm/lib/fssm/path.rb

@@ -1,94 +0,0 @@
-class FSSM::Path
-  def initialize(path=nil, glob=nil, options={}, &block)
-    @options = options
-    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(*args, &block)
-    callback_action(:create, (block_given? ? block : args))
-  end
-
-  def update(*args, &block)
-    callback_action(:update, (block_given? ? block : args))
-  end
-
-  def delete(*args, &block)
-    callback_action(:delete, (block_given? ? block : args))
-  end
-
-  private
-
-  def init_callbacks
-    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?
-      get_callback(type)
-    else
-      run_callback(type, args)
-    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, args)
-    callback_args = split_path(args[0])
-    callback_args << args[1] if @options[:directories]
-
-    begin
-      @callbacks[type].call(*callback_args)
-    rescue Exception => e
-      raise FSSM::CallbackError, "#{type} - #{args[0]}: #{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]
-  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
-  end
-
-  def set_glob(glob)
-    @glob = glob.is_a?(Array) ? glob : [glob]
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'fileutils'
-require 'find'
-require 'pathname'
-
-module FSSM
-  class Pathname < ::Pathname
-    VIRTUAL_REGEX = /^file:([^!]*)!/
-
-    class << self
-      def for(path)
-        path.is_a?(::FSSM::Pathname) ? path : new(path)
-      end
-
-      alias :[] :glob
-    end
-
-    def is_virtual?
-      !!(VIRTUAL_REGEX =~ to_s)
-    end
-
-    def segments
-      path  = to_s
-      array = path.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
-    end
-
-    def glob(pattern, flags = 0, &block)
-      patterns = [pattern].flatten
-      patterns.map! { |p| self.class.glob(to_s + p, flags, &block) }
-      patterns.flatten
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-module FSSM::State
-  class Directory
-    attr_reader :path
-
-    def initialize(path, options={})
-      @path    = path
-      @options = options
-      @cache   = FSSM::Tree::Cache.new
-    end
-
-    def refresh(base=nil, skip_callbacks=false)
-      base_path = FSSM::Pathname.for(base || @path.to_pathname).expand_path
-      previous, current = recache(base_path)
-
-      unless skip_callbacks
-        deleted(previous, current)
-        created(previous, current)
-        modified(previous, current)
-      end
-    end
-
-    private
-
-    def created(previous, current)
-      (current.keys - previous.keys).sort.each do |file|
-        @path.create(file, current[file][1])
-      end
-    end
-
-    def deleted(previous, current)
-      (previous.keys - current.keys).sort.reverse.each do |file|
-        @path.delete(file, previous[file][1])
-      end
-    end
-
-    def modified(previous, current)
-      (current.keys & previous.keys).each do |file|
-        current_data = current[file]
-        @path.update(file, current_data[1]) if (current_data[0] <=> previous[file][0]) != 0
-      end
-    end
-
-    def recache(base)
-      base     = FSSM::Pathname.for(base)
-      previous = cache_entries
-      snapshot(base)
-      current = cache_entries
-      [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
-
-    def cache_entries
-      entries = tag_entries(@cache.files, :file)
-      entries.merge! tag_entries(@cache.directories, :directory) if @options[:directories]
-      entries
-    end
-
-    def tag_entries(entries, tag)
-      tagged_entries = {}
-      entries.each_pair { |fname, mtime| tagged_entries[fname] = [mtime, tag] }
-      tagged_entries
-    end
-  end
-end

data/vendor/sass/vendor/fssm/lib/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.exist?
-      # 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/sass/vendor/fssm/lib/fssm/support.rb

@@ -1,92 +0,0 @@
-require 'rbconfig'
-
-module FSSM::Support
-  class << self
-    def usable_backend
-      choice = case
-                 when mac? && !lion? && !jruby? && carbon_core?
-                   'FSEvents'
-                 when mac? && rb_fsevent?
-                   'RBFSEvent'
-                 when linux? && rb_inotify?
-                   'Inotify'
-                 else
-                   'Polling'
-               end
-
-      if (mac? || linux?) && choice == 'Polling'
-        optimal = case
-                    when mac?
-                      'rb-fsevent'
-                    when linux?
-                      'rb-inotify'
-                  end
-        FSSM.dbg("An optimized backend is available for this platform!")
-        FSSM.dbg("    gem install #{optimal}")
-      end
-
-      choice
-    end
-
-    def backend
-      @@backend ||= usable_backend
-    end
-
-    def jruby?
-      defined?(JRUBY_VERSION)
-    end
-
-    def mac?
-      Config::CONFIG['target_os'] =~ /darwin/i
-    end
-
-    def lion?
-      Config::CONFIG['target_os'] =~ /darwin11/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
-        false
-      end
-    end
-
-    def rb_fsevent?
-      begin
-        require 'rb-fsevent'
-        defined?(FSEvent::VERSION) ? FSEvent::VERSION.to_f >= 0.4 : false
-      rescue LoadError
-        false
-      end
-    end
-
-    def rb_inotify?
-      begin
-        require 'rb-inotify'
-        if defined?(INotify::VERSION)
-          version = INotify::VERSION
-          version[0] > 0 || version[1] >= 6
-        end
-      rescue LoadError
-        false
-      end
-    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/vendor/sass/vendor/fssm/lib/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