homesync 0.2

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+  gem 'rake'
+  if RUBY_PLATFORM =~ /darwin/
+    gem 'rb-fsevent'
+    gem 'growl_notify'
+  end
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 László Bácsi
+
+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,114 @@
+**Note**: This project is being developed following the
+[RDD](http://tom.preston-werner.com/2010/08/23/readme-driven-development.html)
+model. Not all of the functionality described in this README have been
+implemented yet. Missing pieces are noted in the Usage section.
+
+# HomeSync
+
+HomeSync makes it easy to synchronize any file under your home directory
+with other machines through Dropbox by providing a simple commandline
+interface for adding and removing symlinks to your files. Furthermore,
+it knows how to handle several key directories correctly and how to
+synchronize application preferences and data.
+
+## Installation
+
+    $ gem install homesync
+    $ homesync setup [-p ~/path/to/dropbox/homesync]
+
+## How it works
+
+HomeSync uses a directory in your dropbox (`~/Dropbox/HomeSync` by
+default) to store the files and directories you want to be synchronized.
+When you add a file to HomeSync it moves the original file to this
+location and creates a symbolic link in its original place.
+
+Files are always stored in HomeSync with the same relative path they had
+in your home directory. For example, if you have a file in
+`~/Code/script.rb` and you have it synchronized by HomeSync, it will be
+moved to `~/Dropbox/HomeSync/Code/script.rb` and `~/Code/script.rb` will
+be a symbolic link pointing to this new path.
+
+HomeSync handles `plist` files in `~/Library/Preferences/` a bit
+differently. These files are usually overwritten when their application
+exits. HomeSync uses a launch agent to watch this directory and the
+corresponding HomeSync directory for changes. When a file that needs to
+be synced is changed in either of these directories, it would be copied
+to the other folder.
+
+## Usage
+
+    $ homesync setup [-p ~/path/to/dropbox/homesync]
+
+Creates a launch agent to monitor changes of preferences files. The `-p`
+option tells HomeSync where to put synchronized files (defaults to
+`~/Dropbox/HomeSync`). This will be stored in the `~/.homesync`
+configuration file, but all the other commands accept this option too.
+
+    $ homesync sync [--overwrite-local | --overwrite-homesync] ~/path/to/file_or_dir
+
+Tells HomeSync to synchronize the file. This is the default command
+meaning that the command name may be omitted. The outcome of this
+command depends on whether the file exists and whether there's a file
+with the same relative path in HomeSync:
+
+* original file doesn't exist
+  * and homesync file doesn't exist: error
+  * and homesync file exists: create symbolic link to the homesync file
+* original file is a symbolic link
+  * to its homesync file: nothing to do
+  * to somewhere else: error (homesync doesn't handle this case)
+* original file is a regular file or directory
+  * and homesync file doesn't exist: move it to homesync and create
+    symbolic link to it
+  * and homesync file exists: asks whether to overwrite the current
+    local file and sync what's in HomeSync (`--overwrite-local` to do
+    this without aking) or update HomeSync with the current local file
+    in and sync that instead (`--overwrite-homesync` to do this without
+    asking)
+
+    $ homesync unsync [-r] ~/path/to/file_or_directory
+
+*Not implemented yet.* Given that the argument is a symbolic link to an
+existing file or directory in HomeSync, copies this file to its original
+place overwriting the symbolic link. Use the `-r` option to remove the
+file from homesync afterwards.
+
+### Custom behaviors (*none of it implemented yet*)
+
+    $ homesync sync:pref Application
+    $ homesync unsync:pref Application
+
+Syncs or unsyncs the preferences file of the application (e.g. for
+TextMate this would be
+`~/Library/Preferences/com.macromates.textmate.plist`). Symlinking
+wouldn't work because of overwrites, so this works by using a launch
+agent to monitor changes to this file.
+
+    $ homesync sync:appsupport Application
+    $ homesync unsync:appsupport Application
+
+Syncs or unsyncs the application support directory of the application
+(e.g. for TextMate this would be `~/Library/Application
+Support/TextMate`).
+
+    $ homesync sync:app Application
+    $ homesync unsync:app Application
+
+Syncs or unsyncs both the application's preferences file and its
+application support directory.
+
+## 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) 2011 László Bácsi. See LICENSE for details.

data/bin/homesync

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'homesync/version'
+rescue LoadError
+  $:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
+  require 'homesync/version'
+end
+
+if %w(--version -v).include? ARGV.first
+  puts "HomeSync #{HomeSync::VERSION}"
+  exit(0)
+end
+
+require 'homesync/cli'
+
+HomeSync::CLI.start

data/lib/homesync.rb

@@ -0,0 +1,5 @@
+require 'homesync/version'
+
+module HomeSync
+  autoload :CLI, "homesync/cli"
+end

data/lib/homesync/cli.rb

@@ -0,0 +1,164 @@
+require 'thor'
+require 'pathname'
+require 'yaml'
+
+module HomeSync
+  class CLI < Thor
+
+    class_option :homesync_path, :aliases => "-p"
+
+    default_task :sync
+
+    desc "setup", "Create the launch agent and configure HomeSync"
+    long_desc <<-EOH
+      Create a launch agent to monitor changes of preferences files
+      Store homesync path configuration (-p option) in ~/.homesync
+    EOH
+    def setup
+      update_homesync_config if options[:homesync_path]
+      update_launch_agent
+    end
+
+    desc "sync FILE", "Setup syncing for file or directory"
+    long_desc <<-EOH
+      Move the file to the HomeSync directory and create a symbolic link in its
+      place. Or setup a symbolic link in this location if the file doesn't exist
+      but a matching file in HomeSync does.
+
+      When both files exist you will be asked what to do. Alternatively you could
+      tell HomeSync which road to go using one of the options of this command.
+    EOH
+    method_options :overwrite_local => :boolean, :overwrite_homesync => :boolean
+    def sync(path)
+      if options[:overwrite_local] and options[:overwrite_homesync]
+        error "--overwrite-local and --overwrite-homesync cannot be used together"
+      end
+
+      path = Pathname.new(path).expand_path
+      relative_from_home = path.relative_path_from(home_path)
+
+      if relative_from_home.to_s =~ %r{^../}
+        error "#{path} is not inside your home directory"
+      end
+
+      sync_path = homesync_path.join(relative_from_home)
+
+      if path.symlink?
+        target = path.readlink
+        target = path.dirname.realpath.join(target) if target.relative?
+        if target == sync_path
+          error "#{path} is already syncing"
+        else
+          error "#{path} is a symlink pointing somewhere else than its place in #{homesync_path}"
+        end
+      end
+
+      if path.exist?
+        if sync_path.exist?
+          if options[:overwrite_local] or (not options[:overwrite_homesync] and shell.file_collision(path))
+            if path.file? then path.unlink else path.rmtree end
+            path.make_symlink(sync_path.to_s)
+            say "Replaced #{path} with symlink to #{sync_path}"
+          elsif options[:overwrite_homesync] or shell.file_collision(sync_path)
+            if sync_path.file? then sync_path.unlink else sync_path.rmtree end
+            path.rename(sync_path)
+            path.make_symlink(sync_path.to_s)
+            say "Replaced #{sync_path} with local version and created symlink to it"
+          else
+            say "Kept both versions, syncing has been cancelled"
+          end
+        else
+          sync_path.dirname.mkpath
+          path.rename(sync_path)
+          path.make_symlink(sync_path.to_s)
+          say "Moved #{path} to HomeSync and created a symlink to it"
+        end
+      else
+        if sync_path.exist?
+          path.make_symlink(sync_path.to_s)
+          say "Created link to #{sync_path}"
+        else
+          error "#{path} doesn't exist"
+        end
+      end
+    end
+
+  private
+
+    def error(message)
+      raise Thor::Error, message
+    end
+
+    def home_path
+      Pathname.new(ENV['HOME'])
+    end
+
+    def homesync_path
+      Pathname.new(
+        options[:homesync_path] ||
+        homesync_config['homesync_path'] ||
+        "~/Dropbox/HomeSync"
+      ).expand_path
+    end
+
+    def config_file
+      home_path.join(".homesync")
+    end
+
+    def homesync_config
+      @homesync_config ||= config_file.exist? ? YAML.load_file(config_file) : {}
+    end
+
+    def update_homesync_config
+      relative_homesync_path = "~/" + homesync_path.relative_path_from(home_path).to_s
+      if homesync_config['homesync_path'] != relative_homesync_path
+        homesync_config['homesync_path'] = relative_homesync_path
+        config_file.open("w") { |f| f.write(homesync_config.to_yaml) }
+        puts "Configuration written to #{config_file}"
+      end
+    end
+
+    def update_launch_agent
+      launch_agent_path = home_path.join("Library/LaunchAgents/com.icanscale.homesync.plist")
+      executable_path = File.expand_path($0 =~ %r{/} ? $0 : %x{which #{$0}})
+      launch_agent = <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>com.icanscale.homesync</string>
+	<key>OnDemand</key>
+	<true/>
+	<key>ProgramArguments</key>
+	<array>
+		<string>#{executable_path}</string>
+		<string>sync:pref</string>
+	</array>
+	<key>RunAtLoad</key>
+	<true/>
+	<key>WatchPaths</key>
+	<array>
+		<string>#{home_path}/Library/Preferences</string>
+		<string>#{homesync_path}/Library/Preferences</string>
+	</array>
+</dict>
+</plist>
+      EOF
+
+      if launch_agent_path.exist?
+        if launch_agent_path.read == launch_agent
+          say "Launch Agent already exists"
+        else
+          launch_agent_path.open("w") { |f| f.write(launch_agent) }
+          say "Updated Launch Agent"
+        end
+      else
+        launch_agent_path.dirname.mkpath
+        launch_agent_path.open("w") { |f| f.write(launch_agent) }
+        say "Created Launch Agent"
+      end
+    end
+  end
+
+end

data/lib/homesync/version.rb

@@ -0,0 +1,3 @@
+module HomeSync
+  VERSION = "0.2"
+end

data/spec/fixtures/home/Code/hello_world.rb

@@ -0,0 +1 @@
+puts "Hello World!"

data/spec/fixtures/home/Code/hello_world/app.rb

@@ -0,0 +1,5 @@
+require 'sinatra'
+
+get '/' do
+  "Hello World!"
+end

data/spec/fixtures/home/Code/hello_world/config.ru

@@ -0,0 +1,2 @@
+require './app'
+run Sinatra::Application

data/spec/fixtures/home/DB/HS/custom_homesync

@@ -0,0 +1 @@
+abbreviated

data/spec/fixtures/home/Dropbox/HomeSync/bin/colors

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# with numbers
+
+8.times do |i|
+  puts "\e[3#{i}mcolor #{i} \e[1mbold color #{i}\e[0m"
+end

data/spec/fixtures/home/Dropbox/HomeSync/synced

@@ -0,0 +1 @@
+I'm already synced

data/spec/fixtures/home/Dropbox/HomeSync/todo.txt

@@ -0,0 +1 @@
+Use HomeSync to sync files between your computers

data/spec/fixtures/home/bin/colors

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# with color names
+
+%w(black red green yellow blue magenta cyan white).each_with_index do |color, i|
+  padding = " " * (7-color.length)
+  puts "\e[3#{i}m#{i} #{color}#{padding}  \e[1m#{i} bold #{color}\e[0m"
+end

data/spec/fixtures/home/synced

@@ -0,0 +1 @@
+I'm already synced

data/spec/homesync/cli_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+
+describe HomeSync::CLI do
+
+  let(:stdin)  { nil }
+  let(:stdout) { @stdout }
+  let(:stderr) { @stderr }
+  let(:command) { "" }
+  let(:args) { "" }
+  let(:home) { Pathname.new(ENV['HOME']) }
+  let(:homesync_path) { home.join("Dropbox/HomeSync") }
+
+  before do
+    setup_fixtures
+    @stdout, @stderr = capture_io(stdin) { homesync "#{command} #{args}" }
+  end
+
+  describe '#setup' do
+
+    let(:command) { "setup" }
+
+    let(:launch_agent_path) { Pathname.new(File.expand_path("~/Library/LaunchAgents/com.icanscale.homesync.plist")) }
+    let(:launch_agent) { launch_agent_path.read }
+
+    shared_examples_for "a launch agent" do
+      specify { launch_agent_path.should exist }
+      specify { launch_agent.should =~ %r{<string>#{ENV['HOME']}/Library/Preferences</string>} }
+      specify { launch_agent.should =~ %r{<string>#{homesync_path}/Library/Preferences</string>} }
+    end
+
+    shared_examples_for "a launch agent generator" do
+      context "when launch agent doesn't exist" do
+        specify { stdout.should include("Created Launch Agent") }
+        it_should_behave_like "a launch agent"
+      end
+
+      context "when launch agent exists with same content" do
+        before do
+          @stdout, @stderr = capture_io { homesync "#{command} #{args}" }
+        end
+
+        specify { stdout.should include("Launch Agent already exists") }
+        it_should_behave_like "a launch agent"
+      end
+
+      context "when launch agent exists with different content" do
+        before do
+          launch_agent_path.dirname.mkpath
+          File.open(launch_agent_path, "w") { |f| f.write("x") }
+          @stdout, @stderr = capture_io { homesync "#{command} #{args}" }
+        end
+
+        specify { stdout.should include("Updated Launch Agent") }
+        it_should_behave_like "a launch agent"
+      end
+    end
+
+    context "without options" do
+      it_should_behave_like "a launch agent generator"
+    end
+
+    context "with -p option" do
+      let(:args) { "-p ~/DB/HS" }
+      let(:homesync_path) { home.join("DB/HS") }
+
+      it_should_behave_like "a launch agent generator"
+
+      context "creates configuration file to store homesync path" do
+        specify { stdout.should include("Configuration written to") }
+        specify { YAML.load_file(File.expand_path("~/.homesync"))['homesync_path'].should == "~/DB/HS" }
+      end
+    end
+
+  end
+
+  describe '#sync' do
+
+    let(:command) { "sync" }
+
+    context "when argument is not under user's home" do
+      let(:args) { "/bin/bash" }
+      specify { stderr.should include("is not inside your home directory") }
+    end
+
+    context "when argument doesn't exist" do
+      context "and matching file in homesync doesn't exist either" do
+        let(:args) { "~/404" }
+        specify { stderr.should include("doesn't exist") }
+      end
+
+      context "but matching file in homesync does" do
+        let(:args) { "~/todo.txt" }
+        let(:todo) { home.join("todo.txt") }
+
+        specify { stdout.should include("Created link to #{ENV['HOME']}/Dropbox/HomeSync/todo.txt") }
+
+        it "should create a link to the file in HomeSync" do
+          todo.readlink.should == homesync_path.join("todo.txt")
+        end
+      end
+    end
+
+    context "when argument is a link to the matching homesync file" do
+      let(:args) { "~/synced" }
+      specify { stderr.should include("is already syncing") }
+    end
+
+    context "when argument is a link to somewhere else" do
+      let(:args) { "~/existing_link" }
+      specify { stderr.should include("is a symlink pointing somewhere else") }
+    end
+
+    context "when argument is a regular file" do
+      context "and matching file in homesync doesn't exist" do
+        let(:args) { "~/Code/hello_world.rb" }
+        let(:original_file) { home.join("Code/hello_world.rb") }
+        let(:homesync_file) { homesync_path.join("Code/hello_world.rb") }
+
+        specify { stdout.should include("Moved #{original_file} to HomeSync and created a symlink to it") }
+
+        it "should move the original file to HomeSync" do
+          homesync_file.should be_file
+        end
+
+        it "should create a link to the file in HomeSync" do
+          original_file.readlink.should == homesync_file
+        end
+      end
+
+      context "and matching file in homesync also exists" do
+        let(:args) { "~/bin/colors" }
+        let(:local_path) { home.join("bin/colors") }
+        let(:sync_path) { homesync_path.join("bin/colors") }
+        let(:contents) { File.read(local_path) }
+
+        context "without options" do
+          context "answering Yes to overwrite local" do
+            let(:stdin) { "y\n" }
+
+            specify { stdout.should include("Overwrite #{local_path}?") }
+            specify { stdout.should include("Replaced #{local_path} with symlink to #{sync_path}") }
+
+            it "should create a link to the file in HomeSync" do
+              local_path.readlink.should == sync_path
+            end
+
+            it "should keep the HomeSync version of the file" do
+              contents.should include("with numbers")
+            end
+          end
+
+          context "answering No to overwrite local and Yes to overwrite HomeSync" do
+            let(:stdin) { "n\ny\n" }
+
+            specify { stdout.should include("Overwrite #{local_path}?") }
+            specify { stdout.should include("Overwrite #{sync_path}?") }
+            specify { stdout.should include("Replaced #{sync_path} with local version and created symlink to it") }
+
+            it "should create a link to the file in HomeSync" do
+              local_path.readlink.should == sync_path
+            end
+
+            it "should keep the local version of the file" do
+              contents.should include("with color names")
+            end
+          end
+
+          context "answering No both to overwrite local and HomeSync" do
+            let(:stdin) { "n\nn\n" }
+
+            specify { stdout.should include("Overwrite #{local_path}?") }
+            specify { stdout.should include("Overwrite #{sync_path}?") }
+            specify { stdout.should include("Kept both versions, syncing has been cancelled") }
+
+            it "should keep the local file in place" do
+              contents.should include("with color names")
+            end
+
+            it "should keep the HomeSync version of the file" do
+              File.read(sync_path).should include("with numbers")
+            end
+          end
+        end
+
+        context "using --overwrite-local option" do
+          let(:args) { "~/bin/colors --overwrite-local" }
+
+          specify { stdout.should include("Replaced #{local_path} with symlink to #{sync_path}") }
+
+          it "should create a link to the file in HomeSync" do
+            local_path.readlink.should == sync_path
+          end
+
+          it "should keep the HomeSync version of the file" do
+            contents.should include("with numbers")
+          end
+        end
+
+        context "using --overwrite-homesync option" do
+          let(:args) { "~/bin/colors --overwrite-homesync" }
+
+          specify { stdout.should include("Replaced #{sync_path} with local version and created symlink to it") }
+
+          it "should create a link to the file in HomeSync" do
+            local_path.readlink.should == sync_path
+          end
+
+          it "should keep the local version of the file" do
+            contents.should include("with color names")
+          end
+        end
+
+        context "using both --overwrite-local and --overwrite-homesync options" do
+          # this does not make any sense
+          let(:args) { "~/bin/colors --overwrite-local --overwrite-homesync" }
+          specify { stderr.should include("--overwrite-local and --overwrite-homesync cannot be used together") }
+        end
+      end
+    end
+
+    context "when argument is a directory" do
+      context "and matching directory in homesync doesn't exist" do
+        let(:args) { "~/Code/hello_world" }
+        let(:original_dir) { home.join("Code/hello_world") }
+        let(:homesync_dir) { homesync_path.join("Code/hello_world") }
+
+        specify { stdout.should include("Moved #{original_dir} to HomeSync and created a symlink to it") }
+
+        it "should move the original directory to HomeSync" do
+          homesync_dir.should be_directory
+        end
+
+        it "should create a link to the directory in HomeSync" do
+          original_dir.readlink.should == homesync_dir
+        end
+      end
+
+      context "and matching directory in homesync also exists" do
+        let(:args) { "~/tasks" }
+        let(:local_path) { home.join("tasks") }
+        let(:sync_path) { homesync_path.join("tasks") }
+        let(:dir_entries) { local_path.entries.map(&:basename).map(&:to_s) - %w(. ..) }
+
+        context "using --overwrite-local option" do
+          let(:args) { "~/tasks --overwrite-local" }
+
+          specify { stdout.should include("Replaced #{local_path} with symlink to #{sync_path}") }
+
+          it "should create a link to the directory in HomeSync" do
+            local_path.readlink.should == sync_path
+          end
+
+          it "should keep the HomeSync version of the directory" do
+            dir_entries.should =~ %w(home work world_hunger)
+          end
+        end
+
+        context "using --overwrite-homesync option" do
+          let(:args) { "~/tasks --overwrite-homesync" }
+
+          specify { stdout.should include("Replaced #{sync_path} with local version and created symlink to it") }
+
+          it "should create a link to the directory in HomeSync" do
+            local_path.readlink.should == sync_path
+          end
+
+          it "should keep the local version of the directory" do
+            dir_entries.should =~ %w(home garden shopping)
+          end
+        end
+      end
+    end
+
+    context "with custom homesync path" do
+      let(:contents) { File.read(home.join("custom_homesync")).chomp }
+
+      context "provided by the -p option" do
+        let(:args) { "~/custom_homesync -p ~/DB/HS" }
+
+        it "should create the link to the file in the custom homesync path" do
+          contents.should == "abbreviated"
+        end
+      end
+
+      context "stored in ~/.homesync configuration" do
+        let(:args) { "~/custom_homesync" }
+
+        before do
+          home.join(".homesync").open("w") {|f| f.write({'homesync_path' => "~/Dropbox/.homesync"}.to_yaml)}
+          @stdout, @stderr = capture_io { homesync "#{command} #{args}" }
+        end
+
+        it "should create the link to the file in the custom homesync path" do
+          contents.should == "hidden"
+        end
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'homesync'
+require 'stringio'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  #config.filter_run :focus => true
+
+  def capture_io(stdin=nil)
+    begin
+      $stdin  = StringIO.new(stdin) unless stdin.nil?
+      $stdout = StringIO.new
+      $stderr = StringIO.new
+      yield
+      result = [ $stdout.string, $stderr.string ]
+    ensure
+      $stdin  = STDIN
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+    result
+  end
+
+  alias :silence :capture_io
+end
+
+def homesync(arguments)
+  HomeSync::CLI.start(arguments.split(/\s+/))
+end
+
+def setup_fixtures
+  tmp_path = Pathname.new(__FILE__).dirname.join("../tmp/test").expand_path
+  tmp_path.rmtree if tmp_path.exist?
+  tmp_path.join("Users").mkpath
+  ENV['HOME'] = "#{tmp_path}/Users/Alice"
+  fixtures = Pathname.new(__FILE__).dirname.join("fixtures/home")
+  %x{ cp -a #{fixtures} #{ENV['HOME']} }
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: homesync
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Laszlo Bacsi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &2152072400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152072400
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152070720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2152070720
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &2152069240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *2152069240
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &2152067860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *2152067860
+description: ! 'HomeSync makes it easy to synchronize any file under your home directory
+
+  with other machines through Dropbox by providing a simple commandline
+
+  interface for adding and removing symlinks to your files. Furthermore,
+
+  it knows how to handle several key directories correctly and how to
+
+  synchronize application preferences and data.
+
+'
+email: lackac@icanscale.com
+executables:
+- homesync
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/homesync
+- lib/homesync/cli.rb
+- lib/homesync/version.rb
+- lib/homesync.rb
+- spec/fixtures/home/bin/colors
+- spec/fixtures/home/Code/hello_world/app.rb
+- spec/fixtures/home/Code/hello_world/config.ru
+- spec/fixtures/home/Code/hello_world.rb
+- spec/fixtures/home/DB/HS/custom_homesync
+- spec/fixtures/home/Dropbox/HomeSync/bin/colors
+- spec/fixtures/home/Dropbox/HomeSync/synced
+- spec/fixtures/home/Dropbox/HomeSync/tasks/home
+- spec/fixtures/home/Dropbox/HomeSync/tasks/work
+- spec/fixtures/home/Dropbox/HomeSync/tasks/world_hunger
+- spec/fixtures/home/Dropbox/HomeSync/todo.txt
+- spec/fixtures/home/existing_link
+- spec/fixtures/home/synced
+- spec/fixtures/home/tasks/garden
+- spec/fixtures/home/tasks/home
+- spec/fixtures/home/tasks/shopping
+- spec/fixtures/home/to/infinity/and/beyond
+- spec/homesync/cli_spec.rb
+- spec/spec_helper.rb
+- README.md
+- LICENSE
+- Gemfile
+homepage: http://github.com/lackac/homesync
+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: 1059405670017922565
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: nowarning
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: HomeSync helps you synchronize your files with other machines through Dropbox.
+test_files: []