sass 3.2.0.alpha.102 → 3.2.0.alpha.103

data/vendor/fssm/lib/fssm/backends/rbfsevent.rb

@@ -1,42 +0,0 @@
-module FSSM::Backends
-  class RBFSEvent
-    def initialize
-      @handlers = []
-    end
-
-    def add_handler(handler, preload=true)
-      @handlers << handler
-      handler.refresh(nil, true) if preload
-    end
-
-    def run
-      begin
-        @fsevent = FSEvent.new
-        @fsevent.watch(temporary_multipath_hack) do |paths|
-          paths.each do |path|
-            temporary_multipath_handler(path)
-          end
-        end
-        @fsevent.run
-      rescue Interrupt
-        @fsevent.stop
-      end
-    end
-
-    def temporary_multipath_handler(path)
-      @handlers.each do |handler|
-        handler_path = File.join(handler.path.to_s, "")
-        if path.start_with?(handler_path)
-          handler.refresh(path)
-          break
-        end
-      end
-    end
-
-    def temporary_multipath_hack
-      @handlers = @handlers.sort {|x,y| y.path.to_pathname.segments.length <=> x.path.to_pathname.segments.length}
-      return @handlers.map {|handler| handler.path.to_s}
-    end
-
-  end
-end

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

@@ -1,131 +0,0 @@
-OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
-
-module Rucola
-  class FSEvents
-    class FSEvent
-      attr_reader :fsevents_object
-      attr_reader :id
-      attr_reader :path
-
-      def initialize(fsevents_object, id, path)
-        @fsevents_object, @id, @path = fsevents_object, id, path
-      end
-
-      # 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
-      end
-
-      # Returns the last modified file in the path that the event occurred in.
-      def last_modified_file
-        files.first
-      end
-    end
-
-    class StreamError < StandardError;
-    end
-
-    attr_reader :paths
-    attr_reader :stream
-
-    attr_accessor :allocator
-    attr_accessor :context
-    attr_accessor :since
-    attr_accessor :latency
-    attr_accessor :flags
-
-    # Initializes a new FSEvents `watchdog` object and starts watching the directories you specify for events. The
-    # block is used as a handler for events, which are passed as the block's argument. This method is the easiest
-    # way to start watching some directories if you don't care about the details of setting up the event stream.
-    #
-    #   Rucola::FSEvents.start_watching('/tmp') do |events|
-    #     events.each { |event| log.debug("#{event.files.inspect} were changed.") }
-    #   end
-    #   
-    #   Rucola::FSEvents.start_watching('/var/log/system.log', '/var/log/secure.log', :since => last_id, :latency => 5) do
-    #     Growl.notify("Something was added to your log files!")
-    #   end
-    #
-    # Note that the method also returns the FSEvents object. This enables you to control the event stream if you want to.
-    #
-    #   fsevents = Rucola::FSEvents.start_watching('/Volumes') do |events|
-    #     events.each { |event| Growl.notify("Volume changes: #{event.files.to_sentence}") }
-    #   end
-    #   fsevents.stop
-    def self.start_watching(*params, &block)
-      fsevents = new(*params, &block)
-      fsevents.create_stream
-      fsevents.start
-      fsevents
-    end
-
-    # Creates a new FSEvents `watchdog` object. You can specify a list of paths to watch and options to control the
-    # behaviour of the watchdog. The block you pass serves as a callback when an event is generated on one of the
-    # specified paths.
-    #
-    #   fsevents = FSEvents.new('/etc/passwd') { Mailer.send_mail("Someone touched the password file!") }
-    #   fsevents.create_stream
-    #   fsevents.start
-    #
-    #   fsevents = FSEvents.new('/home/upload', :since => UploadWatcher.last_event_id) do |events|
-    #     events.each do |event|
-    #       UploadWatcher.last_event_id = event.id
-    #       event.files.each do |file|
-    #         UploadWatcher.logfile.append("#{file} was changed")
-    #       end
-    #     end
-    #   end
-    #
-    # *:since: The service will report events that have happened after the supplied event ID. Never use 0 because that 
-    #   will cause every fsevent since the "beginning of time" to be reported. Use OSX::KFSEventStreamEventIdSinceNow
-    #   if you want to receive events that have happened after this call. (Default: OSX::KFSEventStreamEventIdSinceNow).
-    #   You can find the ID's passed with :since in the events passed to your block.
-    # *:latency: Number of seconds to wait until an FSEvent is reported, this allows the service to bundle events. (Default: 0.0)
-    #
-    # Please refer to the Cocoa documentation for the rest of the options.
-    def initialize(*params, &block)
-      raise ArgumentError, 'No callback block was specified.' unless block_given?
-
-      options = params.last.kind_of?(Hash) ? params.pop : {}
-      @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
-
-      @user_callback = block
-      @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]) }
-        @user_callback.call(events)
-      end
-    end
-
-    # Create the stream.
-    # Raises a Rucola::FSEvents::StreamError if the stream could not be created.
-    def create_stream
-      @stream = OSX.FSEventStreamCreate(@allocator, @callback, @context, @paths, @since, @latency, @flags)
-      raise(StreamError, 'Unable to create FSEvents stream.') unless @stream
-      OSX.FSEventStreamScheduleWithRunLoop(@stream, OSX.CFRunLoopGetCurrent, OSX::KCFRunLoopDefaultMode)
-    end
-
-    # Start the stream.
-    # Raises a Rucola::FSEvents::StreamError if the stream could not be started.
-    def start
-      raise(StreamError, 'Unable to start FSEvents stream.') unless OSX.FSEventStreamStart(@stream)
-    end
-
-    # Stop the stream.
-    # You can resume it by calling `start` again.
-    def stop
-      OSX.FSEventStreamStop(@stream)
-    end
-  end
-end

data/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/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/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/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/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