prepare for release 0.8.0

Conflicts:
	lib/homesick/actions.rb

.rspec

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

.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.8.7

ChangeLog.markdown

@@ -0,0 +1,62 @@
+# 0.8.0
+ * Introduce commit & push command
+  * commit changes in castle and push to remote
+ * Enable recursive submodule update
+ * Git add when track
+ 
+# 0.7.0
+ * Fixed double-cloning #14
+ * New option for pull command: --all
+  * pulls each castle, instead of just one
+
+# 0.6.1
+
+ * Add a license
+
+# 0.6.0
+
+ * Introduce .homesickrc
+  * Castles can now have a .homesickrc inside them
+  * On clone, this is eval'd inside the destination directory
+ * Introduce track command
+  * Allows easily moving an existing file into a castle, and symlinking it back
+
+# 0.5.0
+
+ * Fixed listing of castles cloned using `homesick clone <github-user>/<github-repo>` (issue 3)
+ * Added `homesick pull <CASTLE>` for updating castles (thanks Jorge Dias!)
+ * Added a very basic `homesick generate <CASTLE>`
+
+# 0.4.1
+
+ * Improved error message when a castle's home dir doesn't exist
+
+# 0.4.0
+
+ * `homesick clone` can now take a path to a directory on the filesystem, which will be symlinked into place
+ * `homesick clone` now tries to `git submodule init` and `git submodule update` if git submodules are defined for a cloned repo
+ * Fixed missing dependency on thor and others
+ * Use HOME environment variable for where to store files, instead of assuming ~
+
+# 0.3.0
+
+ * Renamed 'link' to 'symlink'
+ * Fixed conflict resolution when symlink destination exists and is a normal file
+
+# 0.2.0
+
+ * Better support for recognizing git urls (thanks jacobat!)
+	 * if it looks like a github user/repo, do that
+	 * otherwise hand off to git clone
+ * Listing now displays in color, and show git remote
+ * Support pretend, force, and quiet modes
+
+# 0.1.1
+
+ * Fixed trying to link against castles that don't exist
+ * Fixed linking, which tries to exclude . and .. from the list of files to
+ link (thanks Martinos!)
+
+# 0.1.0
+
+ * Initial release

Gemfile

@@ -1,16 +1,15 @@
+source :gemcutter
+
 # Add dependencies required to use your gem here.
-group :runtime do
-  #gem 'bundler', '>= 0.9.5'
-  gem "thor"
-end
+gem "thor", ">= 0.14.0"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rake"
-  gem "rspec", ">= 1.2.9"
-  gem "bundler", ">= 0.9.5"
-  gem "jeweler", ">= 1.4.0"
-  gem "rcov", ">= 0"
-  gem "devver-construct"
+  gem "rake", "~> 0.8.7"
+  gem "rspec", "~> 2.10"
+  gem "jeweler", ">= 1.6.2"
+  gem "rcov", :platforms => :mri_18
+  gem "simplecov", :platforms => :mri_19
+  gem "test-construct"
 end

Gemfile.lock

@@ -0,0 +1,42 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.3)
+    multi_json (1.3.6)
+    rake (0.8.7)
+    rcov (1.0.0)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    test-construct (1.2.0)
+    thor (0.15.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler (>= 1.6.2)
+  rake (~> 0.8.7)
+  rcov
+  rspec (~> 2.10)
+  simplecov
+  test-construct
+  thor (>= 0.14.0)

README.markdown

@@ -1,14 +1,13 @@
-= homesick
+# homesick
 
 A man's home (directory) is his castle, so don't leave home with out it.
 
-Homesick is sorta like rip, but for dotfiles. It uses git to clone a repository containing dotfiles, and saves them in ~/.homesick. It then allows you to symlink all the dotfiles into place with a single command.
+Homesick is sorta like [rip](http://github.com/defunkt/rip), but for dotfiles. It uses git to clone a repository containing dotfiles, and saves them in `~/.homesick`. It then allows you to symlink all the dotfiles into place with a single command.
 
 We call a repository that is compatible with homesick to be a 'castle'. To act as a castle, a repository must be organized like so:
 
 * Contains a 'home' directory
 * 'home' contains any number of files and directories that begin with '.'
-* Optionally has a README file
 
 To get started, install homesick first:
 
@@ -24,13 +23,33 @@ Alternatively, if it's on github, there's a slightly shorter way:
 
 With the castle cloned, you can now link its contents into your home dir:
 
-    homesick link pickled-vim
+    homesick symlink pickled-vim
+
+If you use the shorthand syntax for GitHub repositories in your clone, please note you will instead need to run:
+
+    homesick symlink technicalpickles/pickled-vim
 
 If you're not sure what castles you have around, you can easily list them:
 
     homesick list
 
-== Note on Patches/Pull Requests
+To pull your castle (or all castles):
+
+    homesick pull --all|CASTLE
+
+To commit your castle's changes:
+
+    homesick commit CASTLE
+
+To push your castle:
+
+    homesick push CASTLE
+
+Not sure what else homesick has up its sleeve? There's always the built in help:
+
+    homesick help
+
+## Note on Patches/Pull Requests
  
 * Fork the project.
 * Make your feature addition or bug fix.
@@ -38,6 +57,10 @@ If you're not sure what castles you have around, you can easily list them:
 * 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
+## Need homesick without the ruby dependency?
+
+Check out [homeshick](https://github.com/andsens/homeshick).
+
+## Copyright
 
 Copyright (c) 2010 Joshua Nichols. See LICENSE for details.

Rakefile

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'bundler'
 begin
-  Bundler.setup(:runtime, :development)
+  Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
   $stderr.puts e.message
   $stderr.puts "Run `bundle install` to install missing gems"
@@ -12,30 +12,36 @@ require 'rake'
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   gem.name = "homesick"
-  gem.summary = %Q{TODO: one-line summary of your gem}
-  gem.description = %Q{TODO: longer description of your gem}
-  gem.email = "josh@technicalpickles.com"
+  gem.summary = %Q{A man's home is his castle. Never leave your dotfiles behind.}
+  gem.description = %Q{
+    A man's home (directory) is his castle, so don't leave home with out it.
+
+    Homesick is sorta like rip, but for dotfiles. It uses git to clone a repository containing dotfiles, and saves them in ~/.homesick. It then allows you to symlink all the dotfiles into place with a single command. 
+
+  }
+  gem.email = ["josh@technicalpickles.com", "info@muratayusuke.com"]
   gem.homepage = "http://github.com/technicalpickles/homesick"
-  gem.authors = ["Joshua Nichols"]
-  gem.version = "0.1.0"
+  gem.authors = ["Joshua Nichols", "Yusuke Murata"]
+  gem.version = "0.8.0"
+  gem.license = "MIT"
   # Have dependencies? Add them to Gemfile
 
   # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
 end
+Jeweler::GemcutterTasks.new
 
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
+RSpec::Core::RakeTask.new(:rcov) do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
   spec.rcov = true
 end
 
+
 task :default => :spec
 
 require 'rake/rdoctask'

bin/homesick

@@ -2,7 +2,7 @@
 
 require 'pathname'
 lib = Pathname.new(__FILE__).dirname.join('..', 'lib').expand_path
-$LOAD_PATH.unshift.unshift lib.to_s unless $LOAD_PATH.include?(lib.to_s)
+$LOAD_PATH.unshift lib.to_s 
 
 require 'homesick'
 

homesick.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "homesick"
+  s.version = "0.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Joshua Nichols", "Yusuke Murata"]
+  s.date = "2013-04-05"
+  s.description = "\n    A man's home (directory) is his castle, so don't leave home with out it.\n\n    Homesick is sorta like rip, but for dotfiles. It uses git to clone a repository containing dotfiles, and saves them in ~/.homesick. It then allows you to symlink all the dotfiles into place with a single command. \n\n  "
+  s.email = ["josh@technicalpickles.com", "info@muratayusuke.com"]
+  s.executables = ["homesick"]
+  s.extra_rdoc_files = [
+    "ChangeLog.markdown",
+    "LICENSE",
+    "README.markdown"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".travis.yml",
+    "ChangeLog.markdown",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "bin/homesick",
+    "homesick.gemspec",
+    "lib/homesick.rb",
+    "lib/homesick/actions.rb",
+    "lib/homesick/shell.rb",
+    "spec/homesick_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/technicalpickles/homesick"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "A man's home is his castle. Never leave your dotfiles behind."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<thor>, [">= 0.14.0"])
+      s.add_development_dependency(%q<rake>, ["~> 0.8.7"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.10"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<test-construct>, [">= 0"])
+    else
+      s.add_dependency(%q<thor>, [">= 0.14.0"])
+      s.add_dependency(%q<rake>, ["~> 0.8.7"])
+      s.add_dependency(%q<rspec>, ["~> 2.10"])
+      s.add_dependency(%q<jeweler>, [">= 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<test-construct>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thor>, [">= 0.14.0"])
+    s.add_dependency(%q<rake>, ["~> 0.8.7"])
+    s.add_dependency(%q<rspec>, ["~> 2.10"])
+    s.add_dependency(%q<jeweler>, [">= 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<test-construct>, [">= 0"])
+  end
+end
+

lib/homesick.rb

@@ -1,130 +1,222 @@
 require 'thor'
 
 class Homesick < Thor
+  autoload :Shell, 'homesick/shell'
+  autoload :Actions, 'homesick/actions'
+
   include Thor::Actions
+  include Homesick::Actions
 
-  # Hack in support for diffing symlinks
-  class Shell < Thor::Shell::Color
+  add_runtime_options!
 
-    def show_diff(destination, content)
-      destination = Pathname.new(destination)
-
-      if destination.symlink?
-        say "- #{destination.readlink}", :red, true
-        say "+ #{content.expand_path}", :green, true
-      else
-        super
-      end
-    end
-
-  end
+  GITHUB_NAME_REPO_PATTERN = /\A([A-Za-z_-]+\/[A-Za-z_-]+)\Z/
 
   def initialize(args=[], options={}, config={})
     super
     self.shell = Homesick::Shell.new
   end
 
-  GIT_URI_PATTERN = /^git:\/\//
-  GITHUB_NAME_REPO_PATTERN = /([A-Za-z_-]+)\/([A-Za-z_-]+)/
-
   desc "clone URI", "Clone +uri+ as a castle for homesick"
   def clone(uri)
-    empty_directory repos_dir, :verbose => false
     inside repos_dir do
-      if uri =~ GIT_URI_PATTERN
-        git_clone uri
+      destination = nil
+      if File.exist?(uri)
+        uri = Pathname.new(uri).expand_path
+        if uri.to_s.start_with?(repos_dir.to_s)
+          raise "Castle already cloned to #{uri}"
+        end
+
+        destination = uri.basename
+
+        ln_s uri, destination
       elsif uri =~ GITHUB_NAME_REPO_PATTERN
-        git_clone "git://github.com/#{$1}/#{$2}.git", "#{$1}_#{$2}"
+        destination = Pathname.new($1)
+        git_clone "git://github.com/#{$1}.git", :destination => destination
+      elsif uri =~ /\/([^\/]*?)(\.git)?\Z/
+        destination = Pathname.new($1)
+        git_clone uri
+      elsif uri =~ /[^:]+:([^:]+)(\.git)?\Z/
+        destination = Pathname.new($1)
+        git_clone uri
+      else
+        raise "Unknown URI format: #{uri}"
+      end
+
+      if destination.join('.gitmodules').exist?
+        inside destination do
+          git_submodule_init
+          git_submodule_update
+        end
+      end
+
+      homesickrc = destination.join('.homesickrc').expand_path
+      if homesickrc.exist?
+        proceed = shell.yes?("#{uri} has a .homesickrc. Proceed with evaling it? (This could be destructive)")
+        if proceed
+          shell.say_status "eval", homesickrc
+          inside destination do
+            eval homesickrc.read, binding, homesickrc.expand_path
+          end
+        else
+          shell.say_status "eval skip", "not evaling #{homesickrc}, #{destination} may need manual configuration", :blue
+        end
       end
     end
   end
 
-  desc "link NAME", "Symlinks all dotfiles from the specified castle"
-  def link(home)
-    inside castle_dir(home) do
-      files = Pathname.glob('.*')[2..-1] # skip . and .., ie the first two
+  desc "pull CASTLE", "Update the specified castle"
+  method_option :all, :type => :boolean, :default => false, :required => false, :desc => "Update all cloned castles"
+  def pull(name="")
+    if options[:all]
+      inside_each_castle do |castle|
+        shell.say castle.to_s.gsub(repos_dir.to_s + '/', '') + ':'
+        update_castle castle
+      end
+    else
+      update_castle name
+    end
+
+  end
+
+  desc "commit CASTLE", "Commit the specified castle's changes"
+  def commit(name)
+    commit_castle name
+
+  end
+
+  desc "push CASTLE", "Push the specified castle"
+  def push(name)
+    push_castle name
+
+  end
+
+  desc "symlink CASTLE", "Symlinks all dotfiles from the specified castle"
+  method_option :force, :default => false, :desc => "Overwrite existing conflicting symlinks without prompting."
+  def symlink(name)
+    check_castle_existance(name, "symlink")
+
+    inside castle_dir(name) do
+      files = Pathname.glob('{.*,*}').reject{|a| [".",".."].include?(a.to_s)}
       files.each do |path|
         absolute_path = path.expand_path
 
-        inside user_dir do
-          adjusted_path = (user_dir + path).basename
+        inside home_dir do
+          adjusted_path = (home_dir + path).basename
 
-          symlink absolute_path, adjusted_path
+          ln_s absolute_path, adjusted_path
         end
       end
     end
   end
 
+  desc "track FILE CASTLE", "add a file to a castle"
+  def track(file, castle)
+    castle = Pathname.new(castle)
+    file = Pathname.new(file)
+    check_castle_existance(castle, 'track')
+
+    absolute_path = file.expand_path
+    castle_path = castle_dir(castle)
+    mv absolute_path, castle_path
+
+    inside home_dir do
+      absolute_path = castle_dir(castle) + file.basename
+      home_path = home_dir + file
+      ln_s absolute_path, home_path
+    end
+    
+    inside castle_path do
+      git_add absolute_path
+    end
+  end
+
   desc "list", "List cloned castles"
   def list
-    inside repos_dir do
-      Pathname.glob('*') do |home|
-        puts home
-      end
+    inside_each_castle do |castle|
+      say_status castle.relative_path_from(repos_dir).to_s, `git config remote.origin.url`.chomp, :cyan
     end
   end
 
+  desc "generate PATH", "generate a homesick-ready git repo at PATH"
+  def generate(castle)
+    castle = Pathname.new(castle).expand_path
 
-  no_tasks do
-    # class method, so it's convenient to stub out during tests
-    def self.user_dir
-      @user_dir ||= Pathname.new('~').expand_path
+    github_user = `git config github.user`.chomp
+    github_user = nil if github_user == ""
+    github_repo = castle.basename
+
+    empty_directory castle
+    inside castle do
+      git_init
+      if github_user
+        url = "git@github.com:#{github_user}/#{github_repo}.git"
+        git_remote_add 'origin', url
       end
 
-    def self.repos_dir
-      @repos_dir ||= Pathname.new('~/.homesick/repos').expand_path
+      empty_directory "home"
+    end
   end
 
-    def repos_dir
-      self.class.repos_dir
-    end
-  end
 
   protected
 
-  # TODO move this to be more like thor's template, empty_directory, etc
-  def git_clone(repo, config = {})
-    config ||= {}
-    destination = config[:destination] || begin
-                                            repo =~ /([^\/]+)\.git$/
-                                            $1
+  def home_dir
+    @home_dir ||= Pathname.new(ENV['HOME'] || '~').expand_path
   end
 
-    destination = Pathname.new(destination) unless destination.kind_of?(Pathname)
-
-    if ! destination.directory?
-      say_status 'git clone', "#{repo} to #{destination.expand_path}", :green if config.fetch(:verbose, true)
-      system "git clone #{repo} #{destination}" unless options[:pretend]
-    else
-      say_status :exist, destination.expand_path, :blue
-    end
-  end
-
-  def symlink(source, destination, config = {})
-    destination = Pathname.new(destination)
-
-    if destination.symlink?
-      if destination.readlink == source
-        say_status :identical, destination.expand_path, :blue
-      else
-        say_status :conflict, "#{destination} exists and points to #{destination.readlink}", :red
-
-        if shell.file_collision(destination) { source }
-          system "ln -sf #{source} #{destination}"
-        end
-      end
-    else
-      say_status :symlink, "#{source.expand_path} to #{destination.expand_path}", :green
-      system "ln -s #{source} #{destination}"
-    end
-  end
-
-  def user_dir
-    self.class.user_dir
+  def repos_dir
+    @repos_dir ||= home_dir.join('.homesick', 'repos').expand_path
   end
 
   def castle_dir(name)
     repos_dir.join(name, 'home')
   end
 
+  def check_castle_existance(name, action)
+    unless castle_dir(name).exist?
+      say_status :error, "Could not #{action} #{name}, expected #{castle_dir(name)} exist and contain dotfiles", :red
+
+      exit(1)
+    end
+  end
+
+  def all_castles
+    dirs = Pathname.glob("#{repos_dir}/**/*/.git")
+    # reject paths that lie inside another castle, like git submodules
+    return dirs.reject do |dir|
+      dirs.any? {|other| dir != other && dir.fnmatch(other.parent.join('*').to_s) }
+    end
+  end
+
+  def inside_each_castle(&block)
+    all_castles.each do |git_dir|
+      castle = git_dir.dirname
+      Dir.chdir castle do # so we can call git config from the right contxt
+        yield castle
+      end
+    end
+  end
+
+  def update_castle(castle)
+    check_castle_existance(castle, "pull")
+    inside repos_dir.join(castle) do
+      git_pull
+      git_submodule_init
+      git_submodule_update
+    end
+  end
+  
+  def commit_castle(castle)
+    check_castle_existance(castle, "commit")
+    inside repos_dir.join(castle) do
+      git_commit_all
+    end
+  end
+
+  def push_castle(castle)
+    check_castle_existance(castle, "push")
+    inside repos_dir.join(castle) do
+      git_push
+    end
+  end
 end

lib/homesick/actions.rb

@@ -0,0 +1,119 @@
+class Homesick
+  module Actions
+    # TODO move this to be more like thor's template, empty_directory, etc
+    def git_clone(repo, config = {})
+      config ||= {}
+      destination = config[:destination] || begin
+        repo =~ /([^\/]+)(?:\.git)?$/
+       $1
+      end
+
+      destination = Pathname.new(destination) unless destination.kind_of?(Pathname)
+      FileUtils.mkdir_p destination.dirname
+
+      if ! destination.directory?
+        say_status 'git clone', "#{repo} to #{destination.expand_path}", :green unless options[:quiet]
+        system "git clone -q #{repo} #{destination}" unless options[:pretend]
+      else
+        say_status :exist, destination.expand_path, :blue unless options[:quiet]
+      end
+    end
+
+    def git_init(path = ".")
+      path = Pathname.new(path)
+
+      inside path do
+        unless path.join('.git').exist?
+          say_status 'git init', '' unless options[:quiet]
+          system "git init >/dev/null" unless options[:pretend]
+        else
+          say_status 'git init', 'already initialized', :blue unless options[:quiet]
+        end
+      end
+    end
+
+    def git_remote_add(name, url)
+      existing_remote = `git config remote.#{name}.url`.chomp
+      existing_remote = nil if existing_remote == ''
+
+      unless existing_remote
+        say_status 'git remote', "add #{name} #{url}" unless options[:quiet]
+        system "git remote add #{name} #{url}" unless options[:pretend]
+      else
+        say_status 'git remote', "#{name} already exists", :blue unless options[:quiet]
+      end
+    end
+
+    def git_submodule_init(config = {})
+      say_status 'git submodule', 'init', :green unless options[:quiet]
+      system "git submodule --quiet init" unless options[:pretend]
+    end
+
+    def git_submodule_update(config = {})
+      say_status 'git submodule', 'update', :green unless options[:quiet]
+      system "git submodule --quiet update --init --recursive >/dev/null 2>&1" unless options[:pretend]
+    end
+
+    def git_pull(config = {})
+      say_status 'git pull', '', :green unless options[:quiet]
+      system "git pull --quiet" unless options[:pretend]
+    end
+
+    def git_push(config = {})
+      say_status 'git push', '', :green unless options[:quiet]
+      system "git push" unless options[:pretend]
+    end
+
+    def git_commit_all(config = {})
+      say_status 'git commit all', '', :green unless options[:quiet]
+      system "git commit -v -a" unless options[:pretend]
+    end
+
+    def git_add(file, config = {})
+      say_status 'git add file', '', :green unless options[:quiet]
+      system "git add #{file}" unless options[:pretend]
+    end
+
+    def mv(source, destination, config = {})
+      source = Pathname.new(source)
+      destination = Pathname.new(destination + source.basename)
+
+      if destination.exist?
+        say_status :conflict, "#{destination} exists", :red unless options[:quiet]
+
+        if options[:force] || shell.file_collision(destination) { source }
+          system "mv #{source} #{destination}" unless options[:pretend]
+        end
+      else
+        # this needs some sort of message here.
+        system "mv #{source} #{destination}" unless options[:pretend]
+      end
+    end
+
+    def ln_s(source, destination, config = {})
+      source = Pathname.new(source)
+      destination = Pathname.new(destination)
+
+      if destination.symlink?
+        if destination.readlink == source
+          say_status :identical, destination.expand_path, :blue unless options[:quiet]
+        else
+          say_status :conflict, "#{destination} exists and points to #{destination.readlink}", :red unless options[:quiet]
+
+          if options[:force] || shell.file_collision(destination) { source }
+            system "ln -nsf #{source} #{destination}" unless options[:pretend]
+          end
+        end
+      elsif destination.exist?
+        say_status :conflict, "#{destination} exists", :red unless options[:quiet]
+
+        if options[:force] || shell.file_collision(destination) { source }
+          system "ln -sf #{source} #{destination}" unless options[:pretend]
+        end
+      else
+        say_status :symlink, "#{source.expand_path} to #{destination.expand_path}", :green unless options[:quiet]
+        system "ln -s #{source} #{destination}" unless options[:pretend]
+      end
+    end
+  end
+end

lib/homesick/shell.rb

@@ -0,0 +1,17 @@
+class Homesick
+  # Hack in support for diffing symlinks
+  class Shell < Thor::Shell::Color
+
+    def show_diff(destination, content)
+      destination = Pathname.new(destination)
+
+      if destination.symlink?
+        say "- #{destination.readlink}", :red, true
+        say "+ #{content.expand_path}", :green, true
+      else
+        super
+      end
+    end
+
+  end
+end

spec/homesick/homesick_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "Homesick" do
-  before do
-    @homesick = Homesick.new
-  end
-
-  it "should clone any git repo" do
-    @homesick.should_receive(:git_clone).with('git://github.com/technicalpickles/pickled-vim.git')
-
-    @homesick.clone "git://github.com/technicalpickles/pickled-vim.git"
-  end
-
-  it "should clone a github repo" do
-    @homesick.should_receive(:git_clone).with('git://github.com/wfarr/dotfiles.git', 'wfarr_dotfiles')
-
-    @homesick.clone "wfarr/dotfiles"
-  end
-end

spec/homesick_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper' 
+
+describe "homesick" do
+  let(:home) { create_construct }
+  after { home.destroy! }
+
+  let(:castles) { home.directory(".homesick/repos") }
+
+  let(:homesick) { Homesick.new }
+
+  before { homesick.stub!(:repos_dir).and_return(castles) }
+
+  describe "clone" do
+    context "of a file" do
+      it "should symlink existing directories" do
+        somewhere = create_construct
+        local_repo = somewhere.directory('wtf')
+
+        homesick.clone local_repo
+
+        castles.join("wtf").readlink.should == local_repo
+      end
+
+      context "when it exists in a repo directory" do
+        before do
+          existing_castle = given_castle("existing_castle")
+          @existing_dir = existing_castle.parent
+        end
+
+        it "should not symlink" do
+          homesick.should_not_receive(:git_clone)
+
+          homesick.clone @existing_dir.to_s rescue nil
+        end
+
+        it "should raise an error" do
+          expect { homesick.clone @existing_dir.to_s }.to raise_error(/already cloned/i)
+        end
+      end
+    end
+
+    it "should clone git repo like git://host/path/to.git" do
+      homesick.should_receive(:git_clone).with('git://github.com/technicalpickles/pickled-vim.git')
+
+      homesick.clone "git://github.com/technicalpickles/pickled-vim.git"
+    end
+
+    it "should clone git repo like git@host:path/to.git" do
+      homesick.should_receive(:git_clone).with('git@github.com:technicalpickles/pickled-vim.git')
+
+      homesick.clone 'git@github.com:technicalpickles/pickled-vim.git'
+    end
+
+    it "should clone git repo like http://host/path/to.git" do
+      homesick.should_receive(:git_clone).with('http://github.com/technicalpickles/pickled-vim.git')
+
+      homesick.clone 'http://github.com/technicalpickles/pickled-vim.git'
+    end
+
+    it "should clone git repo like http://host/path/to" do
+      homesick.should_receive(:git_clone).with('http://github.com/technicalpickles/pickled-vim')
+
+      homesick.clone 'http://github.com/technicalpickles/pickled-vim'
+    end
+
+    it "should clone git repo like host-alias:repos.git" do
+      homesick.should_receive(:git_clone).with('gitolite:pickled-vim.git')
+
+      homesick.clone 'gitolite:pickled-vim.git'
+    end
+
+    it "should not try to clone a malformed uri like malformed" do
+      homesick.should_not_receive(:git_clone)
+
+      homesick.clone 'malformed' rescue nil
+    end
+
+    it "should throw an exception when trying to clone a malformed uri like malformed" do
+      expect { homesick.clone 'malformed' }.to raise_error
+    end
+
+    it "should clone a github repo" do
+      homesick.should_receive(:git_clone).with('git://github.com/wfarr/dotfiles.git', :destination => Pathname.new('wfarr/dotfiles'))
+
+      homesick.clone "wfarr/dotfiles"
+    end
+  end
+
+  describe "symlink" do
+    let(:castle) { given_castle("glencairn") }
+
+    it "links dotfiles from a castle to the home folder" do
+      dotfile = castle.file(".some_dotfile")
+
+      homesick.symlink("glencairn")
+
+      home.join(".some_dotfile").readlink.should == dotfile
+    end
+
+    it "links non-dotfiles from a castle to the home folder" do
+      dotfile = castle.file("bin")
+
+      homesick.symlink("glencairn")
+
+      home.join("bin").readlink.should == dotfile
+    end
+
+    context "when forced" do
+      let(:homesick) { Homesick.new [], :force => true }
+
+      it "can override symlinks to directories" do
+        somewhere_else = create_construct
+        existing_dotdir_link = home.join(".vim")
+        FileUtils.ln_s somewhere_else, existing_dotdir_link
+
+        dotdir = castle.directory(".vim")
+
+        homesick.symlink("glencairn")
+
+        existing_dotdir_link.readlink.should == dotdir
+      end
+    end
+  end
+
+  describe "list" do
+    it "should say each castle in the castle directory" do
+      given_castle('zomg')
+      given_castle('zomg', 'wtf/zomg')
+
+      homesick.should_receive(:say_status).with("zomg", "git://github.com/technicalpickles/zomg.git", :cyan)
+      homesick.should_receive(:say_status).with("wtf/zomg", "git://github.com/technicalpickles/zomg.git", :cyan)
+
+      homesick.list
+    end
+  end
+
+  describe "pull" do
+
+    xit "needs testing"
+
+    describe "--all" do
+      xit "needs testing"
+    end
+
+  end
+
+  describe "commit" do
+
+    xit "needs testing"
+
+  end
+
+  describe "push" do
+
+    xit "needs testing"
+
+  end
+
+  describe "track" do
+    it "should move the tracked file into the castle" do
+      castle = given_castle('castle_repo')
+
+      some_rc_file = home.file '.some_rc_file'
+
+      homesick.track(some_rc_file.to_s, 'castle_repo')
+
+      tracked_file = castle.join(".some_rc_file")
+      tracked_file.should exist
+
+      some_rc_file.readlink.should == tracked_file
+    end
+  end
+end

spec/spec_helper.rb

@@ -1,19 +1,28 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'homesick'
-require 'spec'
-require 'spec/autorun'
+require 'rspec'
+require 'rspec/autorun'
 require 'construct'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.include Construct::Helpers
 
-  config.before do
-    @user_dir = create_construct
-    Homesick.stub!(:user_dir).and_return(@user_dir)
+  config.before { ENV['HOME'] = home.to_s }
+
+  config.before { silence! }
+
+  def silence!
+    homesick.stub(:say_status)
   end
 
-  config.after do
-    @user_dir.destroy!
+  def given_castle(name, path=name)
+    castles.directory(path) do |castle|
+      Dir.chdir(castle) do
+        system "git init >/dev/null 2>&1"
+        system "git remote add origin git://github.com/technicalpickles/#{name}.git >/dev/null 2>&1"
+        return castle.directory("home")
+      end
+    end
   end
 end