sass 3.1.15 → 3.1.16

data/vendor/fssm/fssm.gemspec

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "fssm/version"
-
-Gem::Specification.new do |s|
-  s.name              = "fssm"
-  s.version           = FSSM::VERSION
-  s.platform          = Gem::Platform::RUBY
-  s.authors           = ["Travis Tilley", "Nathan Weizenbaum", "Chris Eppstein",
-                         "Jonathan Castello", "Tuomas Kareinen"]
-  s.email             = ["ttilley@gmail.com"]
-  s.homepage          = "https://github.com/ttilley/fssm"
-  s.summary           = %q{File System State Monitor}
-  s.description       = %q{The File System State Monitor keeps track of the state of any number of paths and will fire events when said state changes (create/update/delete). FSSM supports using FSEvents on MacOS, Inotify on GNU/Linux, and polling anywhere else.}
-
-  s.rubyforge_project = "fssm"
-
-  s.files             = `git ls-files`.split("\n")
-  s.test_files        = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables       = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths     = ["lib"]
-  
-#  s.extensions        = 'ext/rakefile.rb'
-
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", ">= 2.4.0"
-end

data/vendor/fssm/lib/fssm.rb

@@ -1,74 +0,0 @@
-dir = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
-require 'thread'
-
-module FSSM
-  
-  FSSMError         = Class.new(StandardError)
-  FileNotFoundError = Class.new(FSSMError)
-  FileNotRealError  = Class.new(FSSMError)
-  CallbackError     = Class.new(FSSMError)
-  
-  autoload :VERSION,        'fssm/version'
-  autoload :Pathname,       'fssm/pathname'
-  autoload :Support,        'fssm/support'
-  autoload :Tree,           'fssm/tree'
-  autoload :Path,           'fssm/path'
-  autoload :Monitor,        'fssm/monitor'
-  
-  module State
-    autoload :Directory,    'fssm/state/directory'
-    autoload :File,         'fssm/state/file'
-  end
-  
-  module Backends
-    autoload :Polling,      'fssm/backends/polling'
-    autoload :FSEvents,     'fssm/backends/fsevents'
-    autoload :RBFSEvent,    'fssm/backends/rbfsevent'
-    autoload :Inotify,      'fssm/backends/inotify'
-    
-    class << self
-      def set_backend(const_symbol=nil, value=nil)
-        const_symbol ||= :Default
-        value ||= ::FSSM::Support.backend
-        
-        if (value.is_a?(Symbol) || value.is_a?(String))
-          unless const_defined?(value)
-            raise NameError,
-              "uninitialized constant FSSM::Backends::#{value}"
-          end
-          value = const_get(value)
-        end
-        
-        unless value.is_a?(Class)
-          raise ArgumentError,
-            "value must be a class or the symbol of an existing backend"
-        end
-        
-        remove_const(const_symbol) if const_defined?(const_symbol)
-        const_set(const_symbol, value)
-      end
-      
-      def const_missing(symbol)
-        symbol == :Default ? set_backend(symbol, FSSM::Support.backend) : super
-      end
-      
-    end
-  end
- 
-  class << self
-    def dbg(msg=nil)
-      STDERR.puts("FSSM -> #{msg}")
-    end
-
-    def monitor(*args, &block)
-      options = args[-1].is_a?(Hash) ? args.pop : {}
-      monitor = FSSM::Monitor.new(options)
-      FSSM::Support.use_block(args.empty? ? monitor : monitor.path(*args), block)
-
-      monitor.run
-    end
-  end
-  
-end

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

@@ -1,36 +0,0 @@
-require File.join(File.dirname(__FILE__), 'rubycocoa/fsevents')
-
-module FSSM::Backends
-  class FSEvents
-    def initialize
-      @handlers = {}
-      @fsevents = []
-    end
-
-    def add_handler(handler, preload=true)
-      @handlers[handler.path.to_s] = handler
-
-      fsevent                      = Rucola::FSEvents.new(handler.path.to_s, {:latency => 0.5}) do |events|
-        events.each do |event|
-          handler.refresh(event.path)
-        end
-      end
-
-      fsevent.create_stream
-      handler.refresh(nil, true) if preload
-      fsevent.start
-      @fsevents << fsevent
-    end
-
-    def run
-      begin
-        OSX.CFRunLoopRun
-      rescue Interrupt
-        @fsevents.each do |fsev|
-          fsev.stop
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,26 +0,0 @@
-module FSSM::Backends
-  class Inotify
-    def initialize
-      @notifier = INotify::Notifier.new
-    end
-
-    def add_handler(handler, preload=true)
-      @notifier.watch(handler.path.to_s, :recursive, :attrib, :close_write, :create,
-                      :delete, :delete_self, :moved_from, :moved_to, :move_self) do |event|
-        path = FSSM::Pathname.for(event.absolute_name)
-        path = path.dirname unless event.name == "" # Event on root directory
-        handler.refresh(path)
-      end
-
-      handler.refresh(nil, true) if preload
-    end
-
-    def run
-      begin
-        @notifier.run
-      rescue Interrupt
-      end
-    end
-
-  end
-end

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

@@ -1,25 +0,0 @@
-module FSSM::Backends
-  class Polling
-    def initialize(options={})
-      @handlers = []
-      @latency  = options[:latency] || 1.5
-    end
-
-    def add_handler(handler, preload=true)
-      handler.refresh(nil, true) if preload
-      @handlers << handler
-    end
-
-    def run
-      begin
-        loop do
-          start = Time.now.to_f
-          @handlers.each { |handler| handler.refresh }
-          nap_time = @latency - (Time.now.to_f - start)
-          sleep nap_time if nap_time > 0
-        end
-      rescue Interrupt
-      end
-    end
-  end
-end

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