dropbox-sync 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.yardoc

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in dropbox-sync.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,69 @@
+= dropbox-sync
+
+dropbox-sync is a simple command line tool to setup syncing files and directories outside of your Dropbox folders using symlinks.
+This is especially useful for applications for which you want to synchronize data between different machines, but the application 
+expects it files to be on a certain location. This tool will create a symlink in your <tt>~/Dropbox/Sync</tt> folder to any path
+you specify. Dropbox will follow this link and synchronize the contents of the original location. This tool can then setup these
+links easily on other machines as well to complete your synchronization setup.
+
+== Installation
+
+    gem install dropbox-sync
+
+== Warnings
+
+This tool is tested on Mac OSX 10.6. It should work on other OSX versions and Linux too, but this is untested. Before using the 
+tool, always wait until Dropbox finishes syncing everything, and then close the Dropbox application. This will make sure Dropbox 
+does not interfere with this tools operations and the other way around.
+
+Final note: not every application is suitable for this synchronization using Dropbox.
+
+== Usage example
+
+Say, you want to synchronize your Address Book contacts on Mac OS X. First, use this tool to synchronize the Address Book 
+folder: <tt>~/Library/Application Support/AddressBook</tt>. Run the following command:
+
+    dropbox-sync sync "~/Library/Application Support/AddressBook"
+
+This will create a symlink <tt>~/Dropbox/Sync/AddressBook</tt>. Dropbox will start uploading the contents of the folder to 
+your Dropbox account.
+
+On the other machine, wait until Dropbox finishes synchronizing and then quit the application. Instead of a symlink, Dropbox
+will have created a folder called <tt>~/Dropbox/Sync/AddressBook</tt> with all the contents in it. The folder needs to be 
+moved to the original location in <tt>~/Library</tt> so Address Book picks it up. Moreover, we also want to create a 
+symlink on this machine, so any changes on this machine will be synced to Dropbox as well. Run the following command:
+
+    dropbox-sync setup
+
+This will move the folder fro  the <tt>~/Dropbox/Sync</tt> folder to the original location and create a symlink instead.
+Note that usually, there will already a local AddressBook folder around in <tt>~/Library/Application Support</tt>. This
+folder will be moved to <tt>~/Library/Application Support/AddressBook.local_backup</tt> so you won't lose it. You can 
+always move this folder back into it's original location to get your local Address Book back.
+
+The setup command can be run every time there is a change to your Dropbox configuration. It will only setup links that
+have not yet been set up before on the machine.
+
+== Other commands and options
+
+=== <tt>dropbox-sync list</tt>
+
+This will display a list of all the files and directories that are currently being synced.
+
+=== <tt>dropbox-sync unsync <path></tt>
+
+This will "forget" the sync link between your local path and the Dropbox path. The files will be kept both locally
+and on Dropbox.
+
+=== <tt>dropbox-sync destroy <path></tt>
+
+This will destroy the sync link between your local path and the Dropbox path. Your local files will be kept around,
+but they will be removed from Dropbox.
+
+=== <tt>--dropbox-dir <path></tt>
+
+If you are not using the default <tt>~/Dropbox</tt> folder on your system, you should provide the <tt>--dropbox-dir 
+<dropbox-path></tt>  option to every command.
+
+== License
+
+MIT.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks(:name => 'dropbox-sync')

data/bin/dropbox-sync

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+$LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'dropbox_sync'
+
+DropboxSync::CLI.start

data/dropbox-sync.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/dropbox_sync/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "dropbox-sync"
+  s.version     = DropboxSync::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Willem van Bergen']
+  s.email       = ['willem@railsdoctors.com']
+  s.homepage    = "http://github.com/wvanbergen/dropbox-sync"
+  s.summary     = "Tool to synchronize folders between machiens using Dropbox and symbolic links."
+  s.description = <<-D
+    This tool will create symbolic links in the Dropbox folder to synchronize paths outside of it. This
+    will cause Dropbox to synchronize the content with your Dropbox account. This tool can then be used
+    on a different machine (with the same Dropbox account) to recreate the symbolic links and setup
+    synchronization between your machines.
+  D
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_runtime_dependency     "thor"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/dropbox_sync.rb

@@ -0,0 +1,5 @@
+module DropboxSync
+  autoload :VERSION, 'dropbox_sync/version'
+  autoload :CLI,     'dropbox_sync/cli'
+  autoload :Entry,   'dropbox_sync/entry'
+end

data/lib/dropbox_sync/cli.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'thor'
+
+class DropboxSync::CLI < Thor
+
+  class_option "dropbox-dir", :type => :string, :banner => "The location of the Dropbox folder.", :default => '~/Dropbox'
+  
+  def initialize(*)
+    super
+    setup_infrastructure!
+  end
+  
+  
+  desc 'list', "Lists the paths that are currently being synced by Dropbox"
+  def list
+    DropboxSync::Entry.each do |entry|
+      shell.say entry.to_s
+    end
+  end
+  
+  desc 'sync PATH [NAME]', "Creates a symbolic link in the dropbox folder to a file or directory."
+  def sync(path, name = nil)
+    DropboxSync::Entry.create(name || File.basename(path), path)
+  end
+  
+  desc 'unsync NAME', "Removes symlink, but keep all files around, locally and on Dropbox."
+  def unsync(name)
+    entry = DropboxSync::Entry[name]
+    if entry.applied?
+      entry.unapply!
+      shell.say "#{entry.name} is now no longer syncing with Dropbox."
+    else
+      raise "Can only unsync entries that are set up correctly!"
+    end
+  end
+  
+  desc 'destroy NAME', "Removes symlink if it exists, and removes files from Dropbox. Keeps local files around."
+  def destroy(name) 
+    entry = DropboxSync::Entry[name]
+    entry.destroy!
+    shell.say "#{entry.name} is now deleted from Dropbox."
+  end
+  
+  desc 'setup', "Sets up the synced files and folders on this machine."
+  def setup
+    DropboxSync::Entry.each do |entry|
+      shell.say "#{entry.name}"
+
+      if entry.applied?
+        shell.say " - Syncing is already set up."
+        
+      elsif entry.applyable?
+        
+        if entry.target_exist?
+          entry.backup_target!
+          shell.say " - Backed up current version of #{entry.path} as #{entry.backup_path}."
+        end
+
+        entry.apply!
+        shell.say " - Dropbox version moved to #{entry.target_path}."
+        shell.say " - Created link #{entry.sync_path} to enable dropbox syncing."
+
+      else
+        shell.say " - Something is off with this entry!"
+      end
+    end
+  end
+  
+  def help(*)
+    shell.say "Dropbox Sync command line tool - by Willem van Bergen."
+    shell.say
+    shell.say "This tool will create symlinks for files and directories you provide in your Dropbox folder. "
+    shell.say "This will synchronize it with Dropbox. You can then easily recreate the setup on a different "
+    shell.say "machine by running 'dropbox-sync setup'."
+    shell.say
+    shell.say "Wait until all files are synced, and then quit Dropbox before using this tool."
+    shell.say
+    super
+  end
+  
+  protected
+  
+  def setup_infrastructure!
+    if File.directory?(File.expand_path(options['dropbox-dir']))
+      DropboxSync::Entry.sync_folder = File.join(File.expand_path(options['dropbox-dir']), 'Sync')
+    else
+      raise "The dropbox folder was not found on #{options['dropbox-dir']}."
+    end
+  end
+end

data/lib/dropbox_sync/entry.rb

@@ -0,0 +1,143 @@
+class DropboxSync::Entry
+  
+  class << self
+    
+    include Enumerable
+    
+    attr_accessor :sync_folder
+    
+    def sync_foler=(folder)
+      @sync_folder = folder
+      @entries = nil
+    end
+    
+    def settings_file
+      File.join(sync_folder, 'sync-settings.yml')
+    end
+    
+    def each(&block)
+      entries.each(&block)
+    end
+    
+    def add_entry(entry)
+      entries << entry
+      save_entries!
+    end
+
+    def remove_entry(entry)
+      entries.delete(self[entry])
+      save_entries!
+    end
+
+    def entries
+      @entries ||= begin
+        hash = YAML.load(File.read(settings_file)) || {}
+        hash.map { |name, options| DropboxSync::Entry.from_hash(name, options) }
+      end
+    end
+    
+    def [](name_or_path)
+      return name_or_path if name_or_path.kind_of?(DropboxSync::Entry)
+      entries.detect { |entry| entry.name == name_or_path || File.expand_path(name_or_path) == entry.target_path }
+    end
+
+    def save_entries!
+      hash = {}
+      each { |entry| hash[entry.name] = entry.to_hash }
+      File.open(settings_file, 'w') { |io| io.write(YAML.dump(hash)) }
+    end
+    
+    def from_hash(name, options)
+      self.new(name, options['path'])
+    end
+
+    def create(name, path)
+
+      raise "#{path.inspect} not found!" unless File.exist?(path)
+      raise "#{path.inspect} is already being synced!" if entries.any? { |e| e.target_path == File.expand_path(path) }
+      raise "Entry #{name.inspect} already exists, choose another name!" if entries.any? { |e| e.name == name }
+
+      entry = self.new(name, path)
+      entry.create!
+    end
+  end
+  
+  attr_reader :name, :path
+  
+  def initialize(name, path)
+    @name, @path = name, self.class.normalized_path(path)
+  end
+  
+  def self.normalized_path(path)
+    File.expand_path(path).sub(Regexp.new('^' + Regexp.quote(File.expand_path('~'))), '~')
+  end
+
+  def to_hash
+    { 'path' => @path }
+  end  
+  
+  def sync_path
+    File.join(self.class.sync_folder, name)
+  end
+  
+  def create!
+    FileUtils.ln_s(target_path, sync_path)
+    self.class.add_entry(self)
+  end
+  
+  def applied?
+    File.symlink?(sync_path) && File.readlink(sync_path) == target_path && File.exist?(target_path)
+  end
+  
+  def applyable? 
+    File.exist?(sync_path) && !File.symlink?(sync_path) && File.exist?(target_path)
+  end
+  
+  def target_path
+    File.expand_path(path)
+  end
+  
+  def backup_path
+    target_path + '.local_backup'
+  end
+  
+  def target_exist?
+    File.exist?(target_path)
+  end
+  
+  def backup_target!
+    FileUtils.mv(target_path, backup_path)
+  end
+  
+  def apply!
+    raise "Traget already exists" if target_exist?
+    FileUtils.mv(sync_path, target_path)
+    FileUtils.ln_s(target_path, sync_path)
+  end
+  
+  def unapply!
+    raise "Cannot unapply entries that have not been applied!" unless applied?
+    FileUtils.rm(sync_path)
+    FileUtils.cp_r(target_path, sync_path)
+    self.class.remove_entry(self)
+  end
+  
+  def destroy!
+    FileUtils.rm(sync_path) if File.exist?(sync_path)
+    self.class.remove_entry(self)
+  end
+  
+  def status
+    if applied?
+      :applied
+    elsif applyable?
+      :applyable
+    else
+      :invalid
+    end
+  end
+  
+  def to_s
+    "#{name} -> #{path} [#{status}]"
+  end
+end

data/lib/dropbox_sync/version.rb

@@ -0,0 +1,3 @@
+module DropboxSync
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: dropbox-sync
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Willem van Bergen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-05 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+description: "    This tool will create symbolic links in the Dropbox folder to synchronize paths outside of it. This\n    will cause Dropbox to synchronize the content with your Dropbox account. This tool can then be used\n    on a different machine (with the same Dropbox account) to recreate the symbolic links and setup\n    synchronization between your machines.\n"
+email: 
+- willem@railsdoctors.com
+executables: 
+- dropbox-sync
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- bin/dropbox-sync
+- dropbox-sync.gemspec
+- lib/dropbox_sync.rb
+- lib/dropbox_sync/cli.rb
+- lib/dropbox_sync/entry.rb
+- lib/dropbox_sync/version.rb
+- test
+has_rdoc: true
+homepage: http://github.com/wvanbergen/dropbox-sync
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Tool to synchronize folders between machiens using Dropbox and symbolic links.
+test_files: []
+