vidibus-watch_folder 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 André Pankratz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+# Vidibus::WatchFolder [![](http://travis-ci.org/vidibus/vidibus-watch_folder.png)](http://travis-ci.org/vidibus/vidibus-watch_folder)
+
+This gem lets you create multipe watch folders within your application, e.g. to provide individual FTP mount points for customers, maybe in combination with [Vidibus::Pureftpd](https://github.com/vidibus/vidibus-pureftpd).
+
+To store each watch folder configuration, [Mongoid](http://mongoid.org/en/mongoid/index.html) (~> 2.5) is used. Files are processed asynchronously with [DelayedJob](https://github.com/collectiveidea/delayed_job).
+
+This gem is part of [Vidibus](http://vidibus.org), an open source toolset for building distributed (video) applications.
+
+
+## Installation
+
+Add `gem 'vidibus-watch_folder'` to the Gemfile of your application. Then call `bundle install` on your console.
+
+This gem relies on [Listen](https://github.com/guard/listen) to detect changes. If you're on Windows, you'll want to install an additional file system adapter to increase performance:
+
+```ruby
+# Windows only!
+gem 'wdm', '~> 0.0.3'
+```
+
+
+## Usage
+
+### Models
+
+Setting up a custom watch folder model is easy. Since it's a `Mongoid::Document`, all of the `ActiveModel` magic is at your disposal. Just add some watch folder settings:
+
+```ruby
+class Example < Vidibus::WatchFolder::Base
+
+  # Define a root directory to store files in.
+  root Rails.root.join('examples')
+
+  # Define folders that should automatically be created.
+  folders 'in', 'out'
+
+  # Define callbacks to perform when files change.
+  #
+  # Use filter :when to define events to watch. Supported event types are:
+  #   :added, :modified, :removed
+  #
+  # Add filter :delay to perform callback later. Execution will be delayed
+  # until the watched file will not have been changed for given period of time.
+  # This is useful for waiting until an upload is completed.
+  #
+  # Set filter :ignore to exclude file names matching given regex.
+  #
+  # Provide :folders to limit this callback to certain folders.
+  callback :create_upload, {
+    :when => :added,
+    :delay => 1.minute,
+    :folders => 'in',
+    :ignore => /^\.pureftpd-upload/
+  }
+  callback :destroy_upload, :when => :removed
+
+  # Callback to process created files
+  def create_upload(event, path)
+    ...
+  end
+
+  # Callback to handle deleted files
+  def destroy_upload(event, path)
+    ...
+  end
+end
+```
+
+
+### Instances
+
+Handling a watch folder instance is straightforward:
+
+```ruby
+example = Example.create
+
+# Access instance properties
+example.uuid   # => 98fe6010e7b5012f7e4c6c626d58b44c
+example.path   # => '/path/to/rails/examples/98fe6010e7b5012f7e4c6c626d58b44c/'
+example.files  # => ['<FILE_PATH>', ...]
+
+# Destroy the instance (will remove its path, too)
+example.destroy
+```
+
+
+### Listening for file changes
+
+File changes are detected by performing `Vidibus::WatchFolder.listen`. Beware, this method is blocking, so better spawn the daemon.
+
+
+#### Listener daemon
+
+To run the listener as daemon, this gem provides a shell script. Install it with
+
+```
+rails g vidibus:watch_folder
+```
+
+The daemon requires that `gem 'daemons'` is installed. To spawn him, enter
+
+```
+script/watch_folder start
+```
+
+#### Possible caveat
+
+To collect the paths to listen to, `Vidibus::WatchFolder.listen` requires that all classes inheriting `Vidibus::WatchFolder::Base` have been loaded.
+
+Because Rails is autoloading almost everything in development, this requirement is not met without the help of a little hack: To trigger autoloading, the listener collects all aforementioned class names from the `app` directory and constantizes them.
+
+**So here's the caveat:** If you define watch folder models outside of the `app` directory, you'll have to let the listener know. An initializer is perfect for that:
+
+```ruby
+# Collect all watch folder models in lib, too
+Vidibus::WatchFolder.autoload_paths << '/lib/**/*.rb'
+```
+
+
+## Deployment
+
+A Capistrano configuration is included. Require it in your Capistrano `config.rb`.
+
+```ruby
+require 'vidibus/watch_folder/capistrano'
+```
+
+That will add a bunch of callback hooks.
+
+```ruby
+after 'deploy:stop',    'vidibus:watch_folder:stop'
+after 'deploy:start',   'vidibus:watch_folder:start'
+after 'deploy:restart', 'vidibus:watch_folder:restart'
+```
+
+If you need more control over the callbacks, you may load just the recipes without the hooks.
+
+```ruby
+require 'vidibus/watch_folder/capistrano/recipes'
+```
+
+### Shared folders
+
+In case you want to put files into a shared folder, you may run into a validation issue. Here's a configuration for our watch folder example that gets symlinked with a twist:
+
+```ruby
+namespace :examples do
+  task :setup do
+    path = File.join(shared_path, 'examples')
+    run "mkdir -p #{path}"
+    run "chmod -R 777 #{path}"
+  end
+
+  task :symlink do
+    run "ln -nfs #{shared_path}/examples #{release_path}/"
+  end
+end
+
+after 'deploy:setup', 'examples:setup'
+before 'deploy:assets:precompile', 'examples:symlink'
+```
+
+The important thing is the last line. Instead of the usual `after 'deploy:update_code'` hook we're triggering the symlink on `before 'deploy:assets:precompile'`. The reason is that precompiling initializes the Rails app which will fail if the example directory does not exist yet.
+
+
+## Testing
+
+To test this gem, call `bundle install` and `bundle exec rspec spec` on your console.
+
+When testing your application you may want to define a different root path for your watch folder models. Just override them somewhere in your test files, for example in `spec_helper.rb`:
+
+```ruby
+# Set different root for watch folder example
+Example.root('spec/support/examples')
+```
+
+Make sure that directory exists. From your Rails root call:
+
+```
+mkdir spec/support/examples
+touch spec/support/examples/.gitkeep
+```
+
+To clean up the test folders, add the following to your RSpec config:
+
+```ruby
+RSpec.configure do |config|
+  config.before(:each) do
+    FileUtils.rm_r(Dir['spec/support/examples/*'].reject {|e| e == '.gitkeep'})
+  end
+end
+```
+
+
+## Copyright
+
+&copy; 2012 André Pankratz. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,17 @@
+$:.unshift File.expand_path('../lib/', __FILE__)
+
+require 'bundler'
+require 'rdoc/task'
+require 'rspec'
+require 'rspec/core/rake_task'
+require 'vidibus/watch_folder/version'
+
+Bundler::GemHelper.install_tasks
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "vidibus-sysinfo #{Vidibus::WatchFolder::VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--charset=utf-8'
+end

data/lib/generators/vidibus/templates/script

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../config/environment', __FILE__)
+require 'vidibus/watch_folder/daemon'
+
+Vidibus::WatchFolder.autoload_paths << Rails.root.join('app/**/*.rb')
+Vidibus::WatchFolder.path_mapping << [Rails.root.to_s, '.+']
+Vidibus::WatchFolder::Daemon.new(ARGV).daemonize

data/lib/generators/vidibus/watch_folder_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module Vidibus
+  class WatchFolderGenerator < Rails::Generators::Base
+
+    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+    def create_script_file
+      template 'script', 'script/watch_folder'
+      chmod 'script/watch_folder', 0755
+    end
+  end
+end

data/lib/vidibus/watch_folder/base.rb

@@ -0,0 +1,197 @@
+require 'mongoid'
+require 'digest'
+require 'vidibus-uuid'
+
+module Vidibus
+  module WatchFolder
+    class Base
+      include Mongoid::Document
+      include Vidibus::Uuid::Mongoid
+
+      class ConfigError < Error; end
+
+      after_create :setup
+      after_destroy :teardown
+
+      # Return the configured root path
+      def root
+        self.class.config[:root] || raise(ConfigError, 'No root configured')
+      end
+
+      # Return the absolute path to this watch folder.
+      def path
+        File.join(root, uuid) if uuid
+      end
+
+      # Return a list of file paths within this watch folder.
+      def files
+        Dir["#{path}/**/*"].reject do |entry|
+          File.directory?(entry)
+        end
+      end
+
+      # Handle event for given file path.
+      # Unless a checksum is provided, a asynchronous job will be started.
+      # If provided checksum matches the current one (or if execution
+      # shall not be delayed), appropriate callbacks will be performed.
+      def handle(event, file_path, last_checksum = nil)
+        return unless File.exist?(file_path) && !File.directory?(file_path)
+        callbacks = self.class.config[:callback]
+        callbacks.each do |folder, handlers|
+          unless folder == :any
+            pattern = %r(^#{path}/#{folder}/.+$)
+            next unless file_path[pattern]
+          end
+          matching = handlers.select { |c| c[:when].include?(event) }
+          matching.each do |handler|
+            next if handler[:ignore] && file_path.match(handler[:ignore])
+            checksum ||= Vidibus::WatchFolder.checksum(file_path)
+            delay = handler[:delay]
+            if checksum == last_checksum || (last_checksum && !delay)
+              send(handler[:method], event, file_path)
+            else
+              Job.create(uuid, event, file_path, checksum, delay)
+            end
+          end
+        end
+      end
+
+      class << self
+
+        # Set root path of this kind of watch folder.
+        def root(path)
+          path = File.expand_path(path)
+          unless Util::Directory.valid?(path)
+            raise ConfigError, "Given root '#{path}' must be a read and writable folder"
+          end
+          unless Vidibus::WatchFolder.roots.include?(path)
+            Vidibus::WatchFolder.roots << path
+          end
+          config[:root] = path
+        end
+
+        # Define folders to create automatically when an instance of this
+        # kind of watch folder is created.
+        def folders(*args)
+          raise ConfigError, 'Define folders' unless args.any?
+          config[:folders] = string_list(args)
+        end
+
+        # Define callbacks to perform when files change.
+        #
+        # Add filter :when to define events to watch. Supported event types
+        # are :added, :modified, an :removed
+        #
+        # Add filter :delay to perform callback later. Execution will then be
+        # delayed until the watched file will not have been changed for given
+        # period of time. This is useful for waiting until an upload is
+        # completed. If no delay has been configured, execution will be
+        # asynchronous nonetheless.
+        #
+        # Set filter :ignore to exclude file names matching given regex.
+        #
+        # Provide :folders to limit this callback to certain folders.
+        def callback(method, options = {})
+          config[:callback] ||= {}
+          opts = {:method => method}
+          if events = events_options(options)
+            opts[:when] = events
+          end
+          if delay = delay_options(options)
+            opts[:delay] = delay
+          end
+          if ignore = ignore_options(options)
+            opts[:ignore] = ignore
+          end
+          folders_options(options).each do |folder|
+            config[:callback][folder] ||= []
+            config[:callback][folder] << opts
+          end
+        end
+
+        # Inheritable getter for config.
+        def config
+          @config ||= {}
+        end
+
+        # Inheritable setter for config.
+        def config=(value)
+          @config = value
+        end
+
+        # Find an instance of this kind of watch folder by its UUID.
+        # Will raise an exception if no instance can be found.
+        def find_by_uuid(uuid)
+          found = where(:uuid => uuid).first || begin
+            raise(Mongoid::Errors::DocumentNotFound.new(self, :uuid => uuid))
+          end
+        end
+
+        private
+
+        def string_list(input)
+          Array(input).map { |i| i.to_s }
+        end
+
+        def folders_options(options)
+          list = string_list(options.delete(:folders))
+          list = [:any] unless list.any?
+          list
+        end
+
+        def events_options(options)
+          return unless events = string_list(options.delete(:when))
+          if events.any?
+            if (events-EVENTS).any?
+              raise ConfigError, "Only these events are supported: #{EVENTS}"
+            end
+            return events
+          end
+          nil
+        end
+
+        def delay_options(options)
+          return unless delay = options.delete(:delay)
+          unless delay.is_a?(Integer) && delay > 0
+            raise ConfigError, 'Delay must be defined in seconds'
+          end
+          delay
+        end
+
+        def ignore_options(options)
+          return unless ignore = options.delete(:ignore)
+          unless ignore.is_a?(Regexp)
+            raise ConfigError, 'Ignore pattern must be a regular expression'
+          end
+          ignore
+        end
+      end
+
+      private
+
+      def setup
+        setup_path
+        setup_folders
+      end
+
+      def setup_path
+        FileUtils.mkdir_p(path)
+      end
+
+      def setup_folders
+        folders = self.class.config[:folders]
+        return unless folders
+        folders.each do |folder|
+          FileUtils.mkdir_p(File.join(path, folder))
+        end
+      end
+
+      def teardown
+        unless path.to_s.length > 5
+          raise ConfigError, "#{path} is too short! Exiting for security reasons."
+        end
+        FileUtils.rm_r(path) if File.exist?(path)
+      end
+    end
+  end
+end

data/lib/vidibus/watch_folder/capistrano/recipes.rb

@@ -0,0 +1,40 @@
+# Capistrano Recipes for watching folders.
+#
+# Load this file from your Capistrano config.rb:
+# require 'vidibus/watch_folder/capistrano/recipes'
+#
+# Add these callbacks to have the watch_folder process restart when the server
+# is restarted:
+#
+#   after 'deploy:stop',    'vidibus:watch_folder:stop'
+#   after 'deploy:start',   'vidibus:watch_folder:start'
+#   after 'deploy:restart', 'vidibus:watch_folder:restart'
+#
+Capistrano::Configuration.instance.load do
+  namespace :vidibus do
+    namespace :watch_folder do
+      def rails_env
+        fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+      end
+
+      def roles
+        fetch(:delayed_job_server_role, :app)
+      end
+
+      desc 'Stop the watch_folder process'
+      task :stop, :roles => lambda { roles } do
+        run "cd #{current_path};#{rails_env} script/watch_folder stop"
+      end
+
+      desc 'Start the watch_folder process'
+      task :start, :roles => lambda { roles } do
+        run "cd #{current_path};#{rails_env} script/watch_folder start"
+      end
+
+      desc 'Restart the watch_folder process'
+      task :restart, :roles => lambda { roles } do
+        run "cd #{current_path};#{rails_env} script/watch_folder restart"
+      end
+    end
+  end
+end

data/lib/vidibus/watch_folder/capistrano.rb

@@ -0,0 +1,12 @@
+require 'vidibus/watch_folder/capistrano/recipes'
+
+# Run Capistrano Recipes for watching folders.
+#
+# Load this file from your Capistrano config.rb:
+# require 'vidibus/watch_folder/capistrano'
+#
+Capistrano::Configuration.instance.load do
+  after 'deploy:stop',    'vidibus:watch_folder:stop'
+  after 'deploy:start',   'vidibus:watch_folder:start'
+  after 'deploy:restart', 'vidibus:watch_folder:restart'
+end

data/lib/vidibus/watch_folder/daemon.rb

@@ -0,0 +1,46 @@
+begin
+  require 'daemons'
+rescue LoadError
+  raise %(Please add `gem 'daemons' gem to your Gemfile for this to work)
+end
+require 'optparse'
+
+module Vidibus
+  module WatchFolder
+    class Daemon
+
+      def initialize(args)
+        @options = {:pid_dir => "#{Rails.root}/tmp/pids"}
+        options = OptionParser.new do |options|
+          options.banner = "Usage: #{File.basename($0)} start|stop|restart"
+          options.on('-h', '--help', 'Show this message') do
+            puts options
+            exit 1
+          end
+        end
+        @args = options.parse!(args)
+      end
+
+      def daemonize
+        dir = @options[:pid_dir]
+        Dir.mkdir(dir) unless File.exists?(dir)
+        run_process('watch_folder', dir)
+      end
+
+      def run_process(name, dir)
+        Daemons.run_proc(name, :dir => dir, :dir_mode => :normal) { run }
+      end
+
+      def run
+        Dir.chdir(Rails.root)
+        log = File.join(Rails.root, 'log', 'watch_folder.log')
+        Vidibus::WatchFolder.logger = ActiveSupport::BufferedLogger.new(log)
+        Vidibus::WatchFolder.listen
+      rescue => e
+        Vidibus::WatchFolder.logger.fatal(e)
+        STDERR.puts(e.message)
+        exit 1
+      end
+    end
+  end
+end

data/lib/vidibus/watch_folder/job.rb

@@ -0,0 +1,39 @@
+require 'delayed_job_mongoid'
+
+module Vidibus
+  module WatchFolder
+    class Job < Struct.new(:uuid, :event, :path, :checksum, :delay)
+      def enqueue!
+        validate!
+        args = [self]
+        i = delay.to_i
+        if i > 0
+          args << {:run_at => Time.now+i}
+        end
+        Delayed::Job.enqueue(*args).id
+      end
+
+      def perform
+        begin
+          watch_folder.handle(event, path, checksum)
+        rescue Mongoid::Errors::DocumentNotFound
+        end
+      end
+
+      def validate!
+        return if uuid && event && path && checksum
+        raise ArgumentError, 'Provide UUID, event, path, checksum, and an optional delay'
+      end
+
+      def self.create(*args)
+        new(*args).enqueue!
+      end
+
+      private
+
+      def watch_folder
+        Base.find_by_uuid(uuid)
+      end
+    end
+  end
+end

data/lib/vidibus/watch_folder/railtie.rb

@@ -0,0 +1,7 @@
+require 'rails'
+
+module Vidibus
+  module WatchFolder
+    class Railtie < Rails::Railtie; end
+  end
+end

data/lib/vidibus/watch_folder/util/directory.rb

@@ -0,0 +1,17 @@
+module Vidibus
+  module WatchFolder
+    module Util
+      module Directory
+        extend self
+
+        # Check if path is a read- and writable directory.
+        def valid?(path)
+          File.exist?(path) &&
+          File.directory?(path) &&
+          File.readable?(path) &&
+          File.writable?(path)
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/watch_folder/util.rb

@@ -0,0 +1 @@
+require 'vidibus/watch_folder/util/directory'

data/lib/vidibus/watch_folder/version.rb

@@ -0,0 +1,5 @@
+module Vidibus
+  module WatchFolder
+    VERSION = '0.1.0'
+  end
+end

data/lib/vidibus/watch_folder.rb

@@ -0,0 +1,84 @@
+require 'vidibus/watch_folder/util'
+require 'vidibus/watch_folder/base'
+require 'vidibus/watch_folder/job'
+require 'vidibus/watch_folder/railtie' if defined?(Rails::Railtie)
+
+require 'listen'
+
+module Vidibus
+  module WatchFolder
+    extend self
+
+    class Error < StandardError; end
+    class NoRootsError < Error; end
+
+    EVENTS = %w[added modified removed]
+
+    attr_accessor :roots, :logger, :autoload_paths, :path_mapping
+    @roots = []
+    @logger = Logger.new(STDOUT)
+    @autoload_paths = []
+    @path_mapping = []
+
+    # Calculate checksum of given file path
+    def checksum(path)
+      Digest::SHA2.file(path).hexdigest
+    end
+
+    # Listen for changes within all roots
+    def listen
+      autoload
+      unless roots.any?
+        raise NoRootsError, 'No folders to watch!'
+      end
+      roots.uniq!
+      logger.debug("[#{Time.now.utc}] - Listening to #{roots.join(',')}")
+      args = roots + [{:latency => 0.1}]
+      Listen.to(*args) do |modified, added, removed|
+        EVENTS.each do |event|
+          eval(event).each do |path|
+            logger.debug %([#{Time.now.utc}] - #{event}: #{path})
+            begin
+              uuid = path[/^#{roots_regex}\/([^\/]+)\/.+$/, 1] || next
+              begin
+                base = Base.find_by_uuid(uuid)
+                base.handle(event, path)
+              rescue Mongoid::Errors::DocumentNotFound
+                logger.error %([#{Time.now.utc}] - Can't find Vidibus::WatchFolder::Base #{uuid})
+              end
+            rescue => e
+              logger.error("[#{Time.now.utc}] - ERROR in Vidibus::WatchFolder.listen:\n#{e.inspect}\n---\n#{e.backtrace.join("\n")}")
+            end
+          end
+        end
+      end
+    end
+
+    # Constantize all watch folder class names to trigger autoloading.
+    def autoload
+      return unless autoload_paths.any?
+      list = Dir[*autoload_paths].map do |f|
+        File.read(f)[/class ([^<]+) < Vidibus::WatchFolder::Base/, 1]
+      end.compact.map { |k| k.constantize }
+    end
+
+    private
+
+    # Return regular expression for root paths.
+    #
+    # If any path_mapping has been defined, that mapping will be applied.
+    # That is often required to turn absolute path into relative ones in order
+    # to avoid problems with symlinks, because uploaded files will usually go
+    # into a shared directory but the root paths Rails reports are from within
+    # the current release directory.
+    def roots_regex
+      @roots_regex ||= begin
+        _roots = roots.join('|')
+        path_mapping.each do |from, to|
+          _roots.gsub!(from, to)
+        end
+        /(?:#{_roots})/
+      end
+    end
+  end
+end

data/lib/vidibus-watch_folder.rb

@@ -0,0 +1 @@
+require 'vidibus/watch_folder'

metadata

@@ -0,0 +1,256 @@
+--- !ruby/object:Gem::Specification
+name: vidibus-watch_folder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- André Pankratz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+- !ruby/object:Gem::Dependency
+  name: vidibus-uuid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: delayed_job_mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create multiple watch folders within your application, e.g. to provide
+  individual FTP mount points for customers.
+email: andre@vidibus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/vidibus/templates/script
+- lib/generators/vidibus/watch_folder_generator.rb
+- lib/vidibus/watch_folder/base.rb
+- lib/vidibus/watch_folder/capistrano/recipes.rb
+- lib/vidibus/watch_folder/capistrano.rb
+- lib/vidibus/watch_folder/daemon.rb
+- lib/vidibus/watch_folder/job.rb
+- lib/vidibus/watch_folder/railtie.rb
+- lib/vidibus/watch_folder/util/directory.rb
+- lib/vidibus/watch_folder/util.rb
+- lib/vidibus/watch_folder/version.rb
+- lib/vidibus/watch_folder.rb
+- lib/vidibus-watch_folder.rb
+- LICENSE
+- README.md
+- Rakefile
+homepage: https://github.com/vidibus/vidibus-watch_folder
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1021260411944907488
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: vidibus-watch_folder
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Watch folders based on Mongoid with asynchronous processing
+test_files: []