boatman 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Bruz Marzolf
+
+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.rdoc

@@ -0,0 +1,166 @@
+= boatman
+
+Boatman is a simple Ruby DSL for polling directories and ferrying around / manipulating new files that appear in those folders. It was created as an attempt at something more elegant than having numerous scripts that all do very similar file transfer and manipulation tasks.
+
+== Install
+
+Install the boatman gem (assuming you have Ruby and RubyGems):
+
+  gem install boatman
+
+== Example
+
+Get a quick feel for what boatman does with this example.
+
+Create a YAML file to define the task scripts and directories they'll operate on. Let's call it demo.yml:
+
+  tasks:
+  - demo.rb
+  directories:
+    fresh_text_folder: txt_output
+    text_storage_folder: storage
+    
+Now create two folders under the folder where you have demo.yml called "txt_output" and "storage".
+
+Make a task file demo.rb:
+
+  fresh_text_folder.check_every 5.seconds do
+    age :greater_than => 1.second
+
+    files_ending_with "txt" do |file|
+      move file, :to => text_storage_folder
+    end
+  end
+
+Now run your task:
+
+  boatman demo.yml
+
+Now, while boatman is running, open another terminal or a file browser and create a file in the txt_output folder you created called "demo.txt". Wait a bit and it should get moved to the "storage" folder you made.
+
+Hit Ctrl-C to exit out of boatman. You can take a look at the boatman.log file it creates to see a log of what operations have been performed.
+
+== Creating tasks
+
+=== Polling folders
+
+The top level of a boatman task will usually be a directory polling loop. This is accomplished by running the check_every method on a directory specified in your YAML configuration file. The check_every method takes a time interval as its only argument other than a block. Using the example above, running
+
+  fresh_text_folder.check_every 5.seconds do
+    ...
+  end
+
+will run the provided do..end block every 5 seconds in the context of the fresh_text_folder directory.
+
+=== Specifying file/folder criteria
+
+It is often desirable to consider just a subset of the files in the folder being polled. Files/folders can be selected by age and file/folder name. Age can be specified inside the polling folders do..end block:
+
+  # age of the file must be greater than 1 minute
+  age :greater_than => 1.minute
+  
+  # age of the file must be less than 24 hours
+  age :less_than => 24.hours
+
+There are a few ways to select based on file name. Each of these methods accepts a block to run on each selected file/folder:
+
+  # select files by a string or regular expression
+  files_matching /\d+\.tif/ do |file|
+    ...
+  end
+  
+  # select files by a string or regular expression ending
+  files_ending_with "txt" do |file|
+    ...
+  end
+  
+  # select folders by a string or regular expression
+  folders_matching /\d+/ do |folder|
+    ...
+  end
+  
+  # select folders by a string or regular expression ending
+  folders_ending_with "log" do |folder|
+    ...
+  end
+
+=== Copying files/folders
+
+Files/folders can be copied or moved inside the block provided to the file/folder matching methods:
+
+  # move selected files to destination_folder, which needs to be defined in the configuration YAML file.
+  files_ending_with "txt" do |file|
+    move file, :to => destination_folder
+  end
+  
+  # same thing but copy the file instead of moving it
+  files_ending_with "txt" do |file|
+    copy file, :to => destination_folder
+  end
+
+boatman will perform a checksum verification by default in order to catch errors in file transfers. This can be disabled with the disable_checksum_verification directive inside the file/folder matching block:
+
+  files_ending_with "txt" do |file|
+    disable_checksum_verification
+    
+    move file, :to => destination_folder
+  end
+
+Files can optionally be renamed using the :rename parameter for move or copy:
+
+  files_ending_with "txt" do |file|
+    # use the path method on the file
+    new_name = "renamed_" + File.basename(file.path)
+    
+    # file will renamed, e.g. test.txt becomes renamed_test.txt
+    move file, :to => destination_folder, :rename => new_name
+  end
+
+The file being copied/moved can also be modified by passing a block to the copy or move methods. The parameters for the block are the path to read the original file and a the path to write the modified file:
+
+  files_ending_with "txt" do |file|
+    move file, :to => destination_folder do |old_file_name, new_file_name|
+      old_file = File.new(old_file_name, "r")
+      new_file = File.new(new_file_name, "w")
+      
+      old_file.readlines.each do |line|
+        new_file << "# #{line}"
+      end
+    end
+  end
+
+== Configuration Files
+
+YAML configuration files for boatman consist of two parts, tasks and directories.
+
+Under tasks you can specify any number of task files to be loaded and run together. Note that boatman will take care of running each task on the interval it specifies, however the tasks are run serially so a long-running task will prevent subsequent tasks from running until it completes:
+
+  # config.yml
+  tasks:
+  - text_file_reformatter.rb
+  - raw_data_transfer.rb
+  directories:
+  ...
+
+Directories allow you to name directories you'd like to have available to your tasks. It is possible to specify both Windows- and POSIX-style paths:
+
+  # Windows-style
+  my_shared_folder: //mycomputer/myshare
+  
+  # POSIX-style
+  my_shared_folder: /home/bmarzolf/share
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Bruz Marzolf. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "boatman"
+    gem.summary = %Q{Ruby DSL for ferrying around and manipulating files}
+    gem.description = %Q{}
+    gem.email = "bmarzolf@systemsbiology.org"
+    gem.homepage = "http://github.com/bmarzolf/boatman"
+    gem.authors = ["Bruz Marzolf"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "boatman #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/boatman

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+puts "Starting boatman"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'boatman'
+
+Boatman.load(ARGV)
+Boatman.run

data/bin/boatman~

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+puts "Starting boatman"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'boatman'
+
+puts "Logging to boatman.log"
+$logger = Logger.new("boatman.log")
+$logger.level = Logger::INFO
+
+Boatman.load(ARGV)
+Boatman.run

data/lib/boatman/copyable.rb

@@ -0,0 +1,25 @@
+class Boatman
+  module Copyable
+    def copy(file, params, remove_original=false, &block)
+      source_path = file.path
+      base_name = params[:rename] || File.basename(source_path)
+
+      destination_path = File.expand_path(params[:to] + "/" + base_name) 
+
+      return if File.exists?(destination_path)
+
+      begin
+        copy_entry(source_path, destination_path, &block)
+        FileUtils.rm_r source_path if remove_original
+
+        Boatman.logger.info "Successfully copied #{source_path} to #{destination_path}"
+      rescue Exception => e
+        Boatman.logger.error e.message
+      end
+    end
+
+    def move(file, params, &block)
+      copy(file, params, remove_original=true, &block)
+    end
+  end
+end

data/lib/boatman/ext/class.rb

@@ -0,0 +1,48 @@
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end
+
+

data/lib/boatman/ext/fixnum.rb

@@ -0,0 +1,19 @@
+class Fixnum
+  def seconds
+     self
+  end
+  def minutes
+     self * 60
+  end
+  def hours
+     self * 60 * 60
+  end
+  def days
+     self * 60 * 60 * 24
+  end
+
+  alias :second :seconds
+  alias :minute :minutes
+  alias :hour :hours
+  alias :day :days
+end

data/lib/boatman/ext/string.rb

@@ -0,0 +1,10 @@
+class String
+  def check_every(time_interval, &block)
+    Boatman.tasks ||= Array.new
+    Boatman.tasks << {
+      :time_interval => time_interval,
+      :block => block,
+      :directory => Boatman::MonitoredDirectory.new(self)
+    }
+  end
+end

data/lib/boatman/monitored_directory.rb

@@ -0,0 +1,83 @@
+class Boatman
+  class MonitoredDirectory
+    include Copyable
+
+    attr_accessor :path
+    attr_accessor :match_data
+
+    def initialize(path, match_data = nil)
+      @path = path
+      @match_data = match_data
+    end
+
+    def age(params)
+      params.each do |key, value|
+        case key
+        when :greater_than
+          @minimum_age = value
+        when :less_than
+          @maximum_age = value
+        end
+      end
+    end
+
+    def entries_matching(entry_pattern, type, &block)
+      @minimum_age ||= false
+      @maximum_age ||= false
+
+      entry_paths = Dir.entries(@path).grep(/#{entry_pattern}/).collect do |name|
+        "#{@path}/#{name}"
+      end
+
+      Boatman.logger.debug "Found #{entry_paths.size} entries in #{@path}"
+      entry_paths.each do |entry_path|
+        next if type == :file && !File.file?(entry_path)
+        next if type == :directory && !File.directory?(entry_path)
+
+        age = Time.now - File.mtime(entry_path)
+        next if @minimum_age && age < @minimum_age
+        next if @maximum_age && age > @maximum_age
+
+        match_data = entry_path.match(entry_pattern) if entry_pattern.is_a?(Regexp)
+        case type
+        when :file
+          entry = MonitoredFile.new(entry_path, match_data)
+        when :directory
+          entry = MonitoredDirectory.new(entry_path, match_data)
+        end
+
+        entry.instance_eval &block
+      end
+    end
+
+    def files_matching(file_pattern, &block)
+      return entries_matching(file_pattern, type = :file, &block)
+    end
+
+    def files_ending_with(file_ending, &block)
+      return files_matching(/#{file_ending}$/, &block)
+    end
+
+    def folders_matching(folder_pattern, &block)
+      return entries_matching(folder_pattern, type = :directory, &block)
+    end
+
+    def folders_ending_with(folder_ending, &block)
+      return folders_matching(/#{folder_ending}$/, &block)
+    end
+
+    private
+
+    def copy_entry(source_path, destination_path, &block)
+      FileUtils.mkdir_p File.dirname(destination_path)
+      FileUtils.cp_r source_path, destination_path
+      
+      if block_given?
+        yield destination_path, "#{destination_path}.tmp"
+        FileUtils.cp_r "#{destination_path}.tmp", destination_path
+        FileUtils.rm_r "#{destination_path}.tmp"
+      end
+    end
+
+  end
+end

data/lib/boatman/monitored_file.rb

@@ -0,0 +1,40 @@
+class Boatman
+  class MonitoredFile
+    include Copyable
+
+    attr_accessor :path
+    attr_accessor :match_data
+
+    def initialize(file_path, match_data = nil)
+      @path = file_path
+      @match_data = match_data
+    end
+
+    def disable_checksum_verification
+      @checksum_verification_disabled = true
+    end
+
+    private
+
+    def copy_entry(source_path, destination_path, &block)
+      FileUtils.mkdir_p File.dirname(destination_path)
+      FileUtils.cp source_path, destination_path
+      
+      unless @checksum_verification_disabled
+        verify_checksum_matches(source_path, destination_path, &block)
+      end
+
+      if block_given?
+        yield destination_path, "#{destination_path}.tmp"
+        FileUtils.cp "#{destination_path}.tmp", destination_path
+        FileUtils.rm "#{destination_path}.tmp"
+      end
+    end
+
+    def verify_checksum_matches(file_1, file_2)
+      file_1_digest = Digest::MD5.hexdigest( File.read(file_1) )
+      file_2_digest = Digest::MD5.hexdigest( File.read(file_2) )
+      raise "Checksum verification failed when copying #{base_name}" unless  file_1_digest == file_2_digest
+    end
+  end
+end

data/lib/boatman.rb

@@ -0,0 +1,83 @@
+require "yaml"
+require "digest/md5"
+
+require "boatman/ext/class"
+require "boatman/ext/string"
+require "boatman/ext/fixnum"
+
+require "boatman/copyable"
+require "boatman/monitored_directory.rb"
+require "boatman/monitored_file.rb"
+
+class Boatman 
+  cattr_accessor :tasks
+  cattr_accessor :logger
+
+  def self.load(args)
+    if(args.size < 1 || args.size > 2)
+      Boatman.print_usage
+      exit(0)
+    end
+
+    puts "Logging to boatman.log"
+    require 'logger'
+    Boatman.logger = Logger.new("boatman.log")
+    logger.level = Logger::INFO
+
+    @config_file = args[0]
+
+    @working_directory = args[1] || "."
+    Boatman.logger.info "Working directory: #{@working_directory}"
+
+    load_config_file(args[0])
+  end
+
+  def self.load_config_file(file)
+    Boatman.logger.info  "Loading Config File: #{@config_file}"
+    config = YAML.load_file(@config_file)
+
+    @task_files = config["tasks"]
+
+    config["directories"].each do |key, value|
+      Object.class_eval do
+        define_method(key) do
+          return value
+        end
+      end
+    end
+  end
+
+  def self.print_usage
+    puts "Usage: boatman <config file> [<working directory>]"
+  end
+
+  def self.run
+    @task_files.each do |task_file|
+      require "#{@working_directory}/#{task_file}"
+      puts "Added task #{task_file}"
+    end
+
+    interrupted = false
+    trap("INT") { interrupted = true }
+    
+    while true do
+      if interrupted
+        puts "Exiting from boatman"
+        return
+      end
+
+      tasks.each do |task|
+        if task[:last_run].nil? || Time.now - task[:last_run] > task[:time_interval]
+          # do everything in the context of the working directory
+          Dir.chdir(@working_directory) do
+            task[:directory].instance_eval &task[:block]
+          end
+
+          task[:last_run] = Time.now
+        end
+      end
+      
+      sleep 1
+    end
+  end
+end

data/spec/boatman_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Moving new files from one location to another" do
+
+  before(:each) do
+    @working_directory = File.expand_path(File.dirname(__FILE__) + '/data')
+    FileUtils.mkdir_p(@working_directory + '/tmp/source')
+    FileUtils.mkdir_p(@working_directory + '/tmp/destination')
+  end
+
+  def run_boatman
+    thread = Thread.new do
+      Boatman.run
+    end
+    sleep 2
+    thread.exit
+  end
+
+  it "should move based on filename ending" do
+    FileUtils.touch(@working_directory + '/tmp/source/datafile.txt')
+
+    boatman = Boatman.load(["#{@working_directory}/filename_ending.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/datafile.txt').should be_true
+  end
+
+  it "should create the destination folder if it does not yet exist" do
+    FileUtils.rm_rf(@working_directory + '/tmp/destination')
+    FileUtils.touch(@working_directory + '/tmp/source/datafile.txt')
+
+    boatman = Boatman.load(["#{@working_directory}/no_destination_folder.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/datafile.txt').should be_true
+  end
+
+  it "should move based on regular expression match to filename ending" do
+    FileUtils.touch(@working_directory + '/tmp/source/datafile_R.tif')
+    FileUtils.touch(@working_directory + '/tmp/source/datafile.tif')
+
+    boatman = Boatman.load(["#{@working_directory}/filename_ending_regexp.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/datafile_R.tif').should be_true
+    File.exist?(@working_directory + '/tmp/destination/datafile.tif').should be_false
+  end
+
+  it "should move and modify a file" do
+    datafile = File.new(@working_directory + '/tmp/source/datafile.txt', "w")
+    datafile << "Some text"
+    datafile.close
+
+    boatman = Boatman.load(["#{@working_directory}/modify.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/datafile.txt').should be_true
+    File.new(@working_directory + '/tmp/destination/datafile.txt').readlines.should ==
+      ["# Some text"]
+  end
+
+  it "should move and rename a file" do
+    FileUtils.touch(@working_directory + '/tmp/source/datafile.txt')
+
+    boatman = Boatman.load(["#{@working_directory}/rename.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/renamed_datafile.txt').should be_true
+  end
+
+  it "should move a file based on a regular expression on the entire filename" do
+    FileUtils.touch(@working_directory + '/tmp/source/datafile.txt')
+  
+    boatman = Boatman.load(["#{@working_directory}/filename_regexp.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/datafile.txt').should be_true
+  end
+
+  it "should move a folder based on its name" do
+    FileUtils.mkdir(@working_directory + '/tmp/source/bob')
+  
+    boatman = Boatman.load(["#{@working_directory}/folder.yml", @working_directory])
+    run_boatman
+
+    File.exist?(@working_directory + '/tmp/destination/bob').should be_true
+    File.directory?(@working_directory + '/tmp/destination/bob').should be_true
+  end
+
+  after(:each) do
+    FileUtils.rm_rf(@working_directory + '/tmp')
+  end
+
+end

data/spec/data/filename_ending.rb

@@ -0,0 +1,7 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  files_ending_with "txt" do |file|
+    move file, :to => destination_folder
+  end
+end

data/spec/data/filename_ending.yml

@@ -0,0 +1,5 @@
+tasks:
+- filename_ending.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/data/filename_ending_regexp.rb

@@ -0,0 +1,7 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  files_ending_with /(_R|_G)\.tif/ do |file|
+    move file, :to => destination_folder
+  end
+end

data/spec/data/filename_ending_regexp.yml

@@ -0,0 +1,5 @@
+tasks:
+- filename_ending_regexp.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/data/filename_regexp.rb

@@ -0,0 +1,7 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  files_matching /.*file.*\.txt/ do |file|
+    move file, :to => destination_folder
+  end
+end

data/spec/data/filename_regexp.yml

@@ -0,0 +1,5 @@
+tasks:
+- filename_regexp.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/data/folder.rb

@@ -0,0 +1,7 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  folders_matching "bob" do |file|
+    move file, :to => destination_folder
+  end
+end

data/spec/data/folder.yml

@@ -0,0 +1,5 @@
+tasks:
+- folder.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/data/modify.rb

@@ -0,0 +1,17 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  files_ending_with "txt" do |file|
+    move file, :to => destination_folder do |old_file_name, new_file_name|
+      old_file = File.new(old_file_name, "r")
+      new_file = File.new(new_file_name, "w")
+
+      old_file.readlines.each do |line|
+        new_file << "# #{line}"
+      end
+
+      old_file.close
+      new_file.close
+    end
+  end
+end

data/spec/data/modify.yml

@@ -0,0 +1,5 @@
+tasks:
+- modify.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/data/no_destination_folder.rb

@@ -0,0 +1,7 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  files_ending_with "txt" do |file|
+    move file, :to => destination_folder
+  end
+end

data/spec/data/no_destination_folder.yml

@@ -0,0 +1,5 @@
+tasks:
+- no_destination_folder.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/data/rename.rb

@@ -0,0 +1,9 @@
+source_folder.check_every 1.second do
+  age :greater_than => 0.minutes
+
+  files_ending_with "txt" do |file|
+    new_name = "renamed_" + File.basename(file.path)
+
+    move file, :to => destination_folder, :rename => new_name
+  end
+end

data/spec/data/rename.yml

@@ -0,0 +1,5 @@
+tasks:
+- rename.rb
+directories:
+  source_folder: tmp/source
+  destination_folder: tmp/destination

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'boatman'
+require 'spec'
+require 'spec/autorun'
+
+BOATMAN_BIN = File.expand_path(File.dirname(__FILE__) + '/../bin/boatman')
+
+Spec::Runner.configure do |config|
+  config.before(:each) { Boatman.tasks = nil }
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: boatman
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Bruz Marzolf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-22 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: ""
+email: bmarzolf@systemsbiology.org
+executables: 
+- boatman
+- boatman~
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/boatman
+- lib/boatman.rb
+- lib/boatman/copyable.rb
+- lib/boatman/ext/class.rb
+- lib/boatman/ext/fixnum.rb
+- lib/boatman/ext/string.rb
+- lib/boatman/monitored_directory.rb
+- lib/boatman/monitored_file.rb
+- spec/boatman_spec.rb
+- spec/data/filename_ending.rb
+- spec/data/filename_ending.yml
+- spec/data/filename_ending_regexp.rb
+- spec/data/filename_ending_regexp.yml
+- spec/data/filename_regexp.rb
+- spec/data/filename_regexp.yml
+- spec/data/folder.rb
+- spec/data/folder.yml
+- spec/data/modify.rb
+- spec/data/modify.yml
+- spec/data/no_destination_folder.rb
+- spec/data/no_destination_folder.yml
+- spec/data/rename.rb
+- spec/data/rename.yml
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/bmarzolf/boatman
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby DSL for ferrying around and manipulating files
+test_files: 
+- spec/spec_helper.rb
+- spec/boatman_spec.rb
+- spec/data/folder.rb
+- spec/data/modify.rb
+- spec/data/no_destination_folder.rb
+- spec/data/filename_ending_regexp.rb
+- spec/data/filename_ending.rb
+- spec/data/rename.rb
+- spec/data/filename_regexp.rb