Regenerate gemspec for version 0.9.4

Fix #19 homesickrc pathname needs a to_s to eval

.gitignore

@@ -43,3 +43,6 @@ pkg
 # For IDEA:
 .idea/
 *.iml
+
+Gemfile.lock
+vendor/

ChangeLog.markdown

@@ -1,3 +1,22 @@
+# 0.9.4
+ * Use https protocol instead of git protocol
+ * Introduce new commands
+     * `homesick unlink`
+     * `homesick rc`
+
+# 0.9.3
+ * Add recursive option to `homesick clone`
+
+# 0.9.2
+ * Set "dotfiles" as default castle name
+ * Introduce new commands
+     * `homesick show_path`
+     * `homesick status`
+     * `homesick diff`
+
+# 0.9.1
+ * Fixed small bugs: #35, #40
+ 
 # 0.9.0
  * Introduce .homesick_subdir #39
  

Gemfile

@@ -12,4 +12,7 @@ group :development do
   gem "rcov", :platforms => :mri_18
   gem "simplecov", :platforms => :mri_19
   gem "test-construct"
+  if RUBY_VERSION >= '1.9.2'
+    gem "rubocop"
+  end
 end

Gemfile.lock

@@ -1,42 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.2.4)
-    git (1.2.5)
-    jeweler (1.8.4)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-      rdoc
-    json (1.8.0)
-    multi_json (1.7.3)
-    rake (10.0.4)
-    rcov (1.0.0)
-    rdoc (4.0.1)
-      json (~> 1.4)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.1)
-    simplecov (0.7.1)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
-    test-construct (1.2.0)
-    thor (0.18.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  jeweler (>= 1.6.2)
-  rake (>= 0.8.7)
-  rcov
-  rspec (~> 2.10)
-  simplecov
-  test-construct
-  thor (>= 0.14.0)

README.markdown

@@ -31,6 +31,10 @@ If you use the shorthand syntax for GitHub repositories in your clone, please no
 
     homesick symlink technicalpickles/pickled-vim
 
+You can remove symlinks anytime when you don't need them anymore
+
+    homesick unlink pickled-vim
+
 If you're not sure what castles you have around, you can easily list them:
 
     homesick list
@@ -77,9 +81,9 @@ and have home like this:
         |-- elisp
         `-- inits
 
-You may want to symlink only to `castle/home/.config/fooapp` instead of `castle/home/.config` because you already have `~/.config/barapp`. In this case, you can use .homesick_subdir. Please write "directories you want to look up sub direcoties (instead of just first depth)" in this file.
+You may want to symlink only to `castle/home/.config/fooapp` instead of `castle/home/.config` because you already have `~/.config/barapp`. In this case, you can use .homesick_subdir. Please write "directories you want to look up sub directories (instead of just first depth)" in this file.
 
-castle/home/.homesick_subdir
+castle/.homesick_subdir
 
     .config
 
@@ -100,7 +104,7 @@ Or `homesick track NESTED_FILE CASTLE` adds a line automatically. For example:
 
     homesick track .emacs.d/elisp castle
 
-castle/home/.homesick_subdir
+castle/.homesick_subdir
 
     .config
 	.emacs.d

Rakefile

@@ -22,7 +22,7 @@ Jeweler::Tasks.new do |gem|
   gem.email = ["josh@technicalpickles.com", "info@muratayusuke.com"]
   gem.homepage = "http://github.com/technicalpickles/homesick"
   gem.authors = ["Joshua Nichols", "Yusuke Murata"]
-  gem.version = "0.9.0"
+  gem.version = "0.9.4"
   gem.license = "MIT"
   # Have dependencies? Add them to Gemfile
 
@@ -41,8 +41,18 @@ RSpec::Core::RakeTask.new(:rcov) do |spec|
   spec.rcov = true
 end
 
+task :rubocop do
+  if RUBY_VERSION >= '1.9.2'
+    system('rubocop')
+  end
+end
 
-task :default => :spec
+task :test do
+  Rake::Task['spec'].execute
+  Rake::Task['rubocop'].execute
+end
+
+task :default => :test
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|

homesick.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "homesick"
-  s.version = "0.9.0"
+  s.version = "0.9.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joshua Nichols", "Yusuke Murata"]
-  s.date = "2013-06-06"
+  s.date = "2013-07-31"
   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"]
@@ -24,7 +24,6 @@ Gem::Specification.new do |s|
     ".travis.yml",
     "ChangeLog.markdown",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE",
     "README.markdown",
     "Rakefile",
@@ -40,11 +39,11 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/technicalpickles/homesick"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.25"
+  s.rubygems_version = "2.0.3"
   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
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<thor>, [">= 0.14.0"])
@@ -54,6 +53,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<rcov>, [">= 0"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<test-construct>, [">= 0"])
+      s.add_development_dependency(%q<rubocop>, [">= 0"])
     else
       s.add_dependency(%q<thor>, [">= 0.14.0"])
       s.add_dependency(%q<rake>, [">= 0.8.7"])
@@ -62,6 +62,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<rcov>, [">= 0"])
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<test-construct>, [">= 0"])
+      s.add_dependency(%q<rubocop>, [">= 0"])
     end
   else
     s.add_dependency(%q<thor>, [">= 0.14.0"])
@@ -71,6 +72,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<rcov>, [">= 0"])
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<test-construct>, [">= 0"])
+    s.add_dependency(%q<rubocop>, [">= 0"])
   end
 end
 

lib/homesick.rb

@@ -10,14 +10,16 @@ class Homesick < Thor
   add_runtime_options!
 
   GITHUB_NAME_REPO_PATTERN = /\A([A-Za-z_-]+\/[A-Za-z_-]+)\Z/
-  SUBDIR_FILENAME = ".homesick_subdir"
+  SUBDIR_FILENAME = '.homesick_subdir'
 
-  def initialize(args=[], options={}, config={})
+  DEFAULT_CASTLE_NAME = 'dotfiles'
+
+  def initialize(args = [], options = {}, config = {})
     super
     self.shell = Homesick::Shell.new
   end
 
-  desc "clone URI", "Clone +uri+ as a castle for homesick"
+  desc 'clone URI', 'Clone +uri+ as a castle for homesick'
   def clone(uri)
     inside repos_dir do
       destination = nil
@@ -32,8 +34,8 @@ class Homesick < Thor
         ln_s uri, destination
       elsif uri =~ GITHUB_NAME_REPO_PATTERN
         destination = Pathname.new($1)
-        git_clone "git://github.com/#{$1}.git", :destination => destination
+        git_clone "https://github.com/#{$1}.git", :destination => destination
-      elsif uri =~ /\/([^\/]*?)(\.git)?\Z/
+      elsif uri =~ /%r([^%r]*?)(\.git)?\Z/
         destination = Pathname.new($1)
         git_clone uri
       elsif uri =~ /[^:]+:([^:]+)(\.git)?\Z/
@@ -50,24 +52,32 @@ class Homesick < Thor
         end
       end
 
+      rc(destination)
+    end
+  end
+
+  desc 'rc CASTLE', 'Run the .homesickrc for the specified castle'
+  def rc(name = DEFAULT_CASTLE_NAME)
+    inside repos_dir do
+      destination = Pathname.new(name)
       homesickrc = destination.join('.homesickrc').expand_path
       if homesickrc.exist?
-        proceed = shell.yes?("#{uri} has a .homesickrc. Proceed with evaling it? (This could be destructive)")
+        proceed = shell.yes?("#{name} has a .homesickrc. Proceed with evaling it? (This could be destructive)")
         if proceed
-          shell.say_status "eval", homesickrc
+          shell.say_status 'eval', homesickrc
           inside destination do
-            eval homesickrc.read, binding, homesickrc.expand_path
+            eval homesickrc.read, binding, homesickrc.expand_path.to_s
           end
         else
-          shell.say_status "eval skip", "not evaling #{homesickrc}, #{destination} may need manual configuration", :blue
+          shell.say_status 'eval skip', "not evaling #{homesickrc}, #{destination} may need manual configuration", :blue
         end
       end
     end
   end
 
-  desc "pull CASTLE", "Update the specified castle"
+  desc 'pull CASTLE', 'Update the specified castle'
-  method_option :all, :type => :boolean, :default => false, :required => false, :desc => "Update all cloned castles"
+  method_option :all, :type => :boolean, :default => false, :required => false, :desc => 'Update all cloned castles'
-  def pull(name="")
+  def pull(name = DEFAULT_CASTLE_NAME)
     if options[:all]
       inside_each_castle do |castle|
         shell.say castle.to_s.gsub(repos_dir.to_s + '/', '') + ':'
@@ -79,22 +89,38 @@ class Homesick < Thor
 
   end
 
-  desc "commit CASTLE", "Commit the specified castle's changes"
+  desc 'commit CASTLE', "Commit the specified castle's changes"
-  def commit(name)
+  def commit(name = DEFAULT_CASTLE_NAME)
     commit_castle name
 
   end
 
-  desc "push CASTLE", "Push the specified castle"
+  desc 'push CASTLE', 'Push the specified castle'
-  def push(name)
+  def push(name = DEFAULT_CASTLE_NAME)
     push_castle name
-
   end
 
-  desc "symlink CASTLE", "Symlinks all dotfiles from the specified castle"
+  desc 'unlink CASTLE', 'Unsymlinks all dotfiles from the specified castle'
-  method_option :force, :default => false, :desc => "Overwrite existing conflicting symlinks without prompting."
+  def unlink(name = DEFAULT_CASTLE_NAME)
-  def symlink(name)
+    check_castle_existance(name, 'symlink')
-    check_castle_existance(name, "symlink")
+
+    inside castle_dir(name) do
+      subdirs = subdirs(name)
+
+      # unlink files
+      unsymlink_each(name, castle_dir(name), subdirs)
+
+      # unlink files in subdirs
+      subdirs.each do |subdir|
+        unsymlink_each(name, subdir, subdirs)
+      end
+    end
+  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 = DEFAULT_CASTLE_NAME)
+    check_castle_existance(name, 'symlink')
 
     inside castle_dir(name) do
       subdirs = subdirs(name)
@@ -109,8 +135,8 @@ class Homesick < Thor
     end
   end
 
-  desc "track FILE CASTLE", "add a file to a castle"
+  desc 'track FILE CASTLE', 'add a file to a castle'
-  def track(file, castle)
+  def track(file, castle = DEFAULT_CASTLE_NAME)
     castle = Pathname.new(castle)
     file = Pathname.new(file.chomp('/'))
     check_castle_existance(castle, 'track')
@@ -149,24 +175,44 @@ class Homesick < Thor
     end
 
     # are we tracking something nested? Add the parent dir to the manifest
-    unless relative_dir.eql?(Pathname.new('.'))
+    subdir_add(castle, relative_dir) unless relative_dir.eql?(Pathname.new('.'))
-      subdir_add(castle, relative_dir)
-    end
   end
 
-  desc "list", "List cloned castles"
+  desc 'list', 'List cloned castles'
   def list
     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"
+  desc 'status CASTLE', 'Shows the git status of a castle'
+  def status(castle = DEFAULT_CASTLE_NAME)
+    check_castle_existance(castle, 'status')
+    inside repos_dir.join(castle) do
+      git_status
+    end
+  end
+
+  desc 'diff CASTLE', 'Shows the git diff of uncommitted changes in a castle'
+  def diff(castle = DEFAULT_CASTLE_NAME)
+    check_castle_existance(castle, 'diff')
+    inside repos_dir.join(castle) do
+      git_diff
+    end
+  end
+
+  desc 'show_path CASTLE', 'Prints the path of a castle'
+  def show_path(castle = DEFAULT_CASTLE_NAME)
+    check_castle_existance(castle, 'show_path')
+    say repos_dir.join(castle)
+  end
+
+  desc 'generate PATH', 'generate a homesick-ready git repo at PATH'
   def generate(castle)
     castle = Pathname.new(castle).expand_path
 
     github_user = `git config github.user`.chomp
-    github_user = nil if github_user == ""
+    github_user = nil if github_user == ''
     github_repo = castle.basename
 
     empty_directory castle
@@ -177,7 +223,7 @@ class Homesick < Thor
         git_remote_add 'origin', url
       end
 
-      empty_directory "home"
+      empty_directory 'home'
     end
   end
 
@@ -208,7 +254,9 @@ class Homesick < Thor
     dirs = Pathname.glob("#{repos_dir}/**/.git", File::FNM_DOTMATCH)
     # 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) }
+      dirs.any? do |other|
+        dir != other && dir.fnmatch(other.parent.join('*').to_s)
+      end
     end
   end
 
@@ -222,7 +270,7 @@ class Homesick < Thor
   end
 
   def update_castle(castle)
-    check_castle_existance(castle, "pull")
+    check_castle_existance(castle, 'pull')
     inside repos_dir.join(castle) do
       git_pull
       git_submodule_init
@@ -231,14 +279,14 @@ class Homesick < Thor
   end
 
   def commit_castle(castle)
-    check_castle_existance(castle, "commit")
+    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")
+    check_castle_existance(castle, 'push')
     inside repos_dir.join(castle) do
       git_push
     end
@@ -262,7 +310,9 @@ class Homesick < Thor
   def subdir_add(castle, path)
     subdir_filepath = subdir_file(castle)
     File.open(subdir_filepath, 'a+') do |subdir|
-      subdir.puts path unless subdir.readlines.inject(false) { |memo, line| line.eql?("#{path.to_s}\n") || memo }
+      subdir.puts path unless subdir.readlines.reduce(false) do |memo, line|
+        line.eql?("#{path.to_s}\n") || memo
+      end
     end
 
     inside castle_dir(castle) do
@@ -305,10 +355,10 @@ class Homesick < Thor
     first_p.mtime > second_p.mtime && !first_p.symlink?
   end
 
-  def symlink_each(castle, basedir, subdirs)
+  def each_file(castle, basedir, subdirs)
     absolute_basedir = Pathname.new(basedir).expand_path
     inside basedir do
-      files = Pathname.glob('{.*,*}').reject{|a| [".", ".."].include?(a.to_s)}
+      files = Pathname.glob('{.*,*}').reject{ |a| ['.', '..'].include?(a.to_s) }
       files.each do |path|
         absolute_path = path.expand_path
         castle_home = castle_dir(castle)
@@ -334,8 +384,21 @@ class Homesick < Thor
 
         relative_dir = absolute_basedir.relative_path_from(castle_home)
         home_path = home_dir.join(relative_dir).join(path)
+
+        yield(absolute_path, home_path)
+      end
+    end
+  end
+
+  def unsymlink_each(castle, basedir, subdirs)
+    each_file(castle, basedir, subdirs) do |absolute_path, home_path|
+      rm_link home_path
+    end
+  end
+
+  def symlink_each(castle, basedir, subdirs)
+    each_file(castle, basedir, subdirs) do |absolute_path, home_path|
       ln_s absolute_path, home_path
     end
   end
-  end
 end

lib/homesick/actions.rb

@@ -3,29 +3,26 @@ class Homesick
     # TODO move this to be more like thor's template, empty_directory, etc
     def git_clone(repo, config = {})
       config ||= {}
-      destination = config[:destination] || begin
+      destination = config[:destination] || File.basename(repo, '.git')
-        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]
+        system "git clone -q --recursive #{repo} #{destination}" unless options[:pretend]
       else
         say_status :exist, destination.expand_path, :blue unless options[:quiet]
       end
     end
 
-    def git_init(path = ".")
+    def git_init(path = '.')
       path = Pathname.new(path)
 
       inside path do
-        unless path.join('.git').exist?
+        if !path.join('.git').exist?
           say_status 'git init', '' unless options[:quiet]
-          system "git init >/dev/null" unless options[:pretend]
+          system 'git init >/dev/null' unless options[:pretend]
         else
           say_status 'git init', 'already initialized', :blue unless options[:quiet]
         end
@@ -36,7 +33,7 @@ class Homesick
       existing_remote = `git config remote.#{name}.url`.chomp
       existing_remote = nil if existing_remote == ''
 
-      unless existing_remote
+      if !existing_remote
         say_status 'git remote', "add #{name} #{url}" unless options[:quiet]
         system "git remote add #{name} #{url}" unless options[:pretend]
       else
@@ -46,27 +43,27 @@ class Homesick
 
     def git_submodule_init(config = {})
       say_status 'git submodule', 'init', :green unless options[:quiet]
-      system "git submodule --quiet init" unless options[:pretend]
+      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]
+      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]
+      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]
+      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]
+      system 'git commit -v -a' unless options[:pretend]
     end
 
     def git_add(file, config = {})
@@ -74,6 +71,16 @@ class Homesick
       system "git add #{file}" unless options[:pretend]
     end
 
+    def git_status(config = {})
+      say_status 'git status', '', :green unless options[:quiet]
+      system "git status" unless options[:pretend]
+    end
+
+    def git_diff(config = {})
+      say_status 'git diff', '', :green unless options[:quiet]
+      system "git diff" unless options[:pretend]
+    end
+
     def mv(source, destination, config = {})
       source = Pathname.new(source)
       destination = Pathname.new(destination + source.basename)
@@ -90,6 +97,17 @@ class Homesick
       end
     end
 
+    def rm_link(target)
+      target = Pathname.new(target)
+
+      if target.symlink?
+        say_status :unlink, "#{target.expand_path}", :green unless options[:quiet]
+        FileUtils.rm_rf target
+      else
+        say_status :conflict, "#{target} is not a symlink", :red unless options[:quiet]
+      end
+    end
+
     def ln_s(source, destination, config = {})
       source = Pathname.new(source)
       destination = Pathname.new(destination)
@@ -109,6 +127,7 @@ class Homesick
         say_status :conflict, "#{destination} exists", :red unless options[:quiet]
 
         if options[:force] || shell.file_collision(destination) { source }
+          system "rm -rf #{destination}" unless options[:pretend]
           system "ln -sf #{source} #{destination}" unless options[:pretend]
         end
       else

spec/homesick_spec.rb

@@ -1,217 +1,397 @@
 require 'spec_helper'
 
-describe "homesick" do
+describe 'homesick' do
   let(:home) { create_construct }
   after { home.destroy! }
 
-  let(:castles) { home.directory(".homesick/repos") }
+  let(:castles) { home.directory('.homesick/repos') }
 
   let(:homesick) { Homesick.new }
 
-  before { homesick.stub!(:repos_dir).and_return(castles) }
+  before { homesick.stub(:repos_dir).and_return(castles) }
 
-  describe "clone" do
+  describe 'clone' do
-    context "of a file" do
+    context 'has a .homesickrc' do
-      it "should symlink existing directories" do
+      it 'should run the .homesickrc' do
+        somewhere = create_construct
+        local_repo = somewhere.directory('some_repo')
+        local_repo.file('.homesickrc') do |file|
+          file << "File.open(Dir.pwd + '/testing', 'w') { |f| f.print 'testing' }"
+        end
+
+        expect($stdout).to receive(:print)
+        expect($stdin).to receive(:gets).and_return('y')
+        homesick.clone local_repo
+
+        castles.join('some_repo').join('testing').should exist
+      end
+    end
+
+    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
+        castles.join('wtf').readlink.should == local_repo
       end
 
-      context "when it exists in a repo directory" do
+      context 'when it exists in a repo directory' do
         before do
-          existing_castle = given_castle("existing_castle")
+          existing_castle = given_castle('existing_castle')
           @existing_dir = existing_castle.parent
         end
 
-        it "should not symlink" do
+        it 'should raise an error' 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
+    it 'should clone git repo like file:///path/to.git' do
-      homesick.should_receive(:git_clone).with('git://github.com/technicalpickles/pickled-vim.git')
+      bare_repo = File.join(create_construct.to_s, 'dotfiles.git')
+      system "git init --bare #{bare_repo} >/dev/null 2>&1"
 
-      homesick.clone "git://github.com/technicalpickles/pickled-vim.git"
+      homesick.clone "file://#{bare_repo}"
+      File.directory?(File.join(home.to_s, '.homesick/repos/dotfiles')).should be_true
     end
 
-    it "should clone git repo like git@host:path/to.git" do
+    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
+    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
+    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
+    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
+    it 'should throw an exception when trying 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
+    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.should_receive(:git_clone).with('https://github.com/wfarr/dotfiles.git', :destination => Pathname.new('wfarr/dotfiles'))
 
-      homesick.clone "wfarr/dotfiles"
+      homesick.clone 'wfarr/dotfiles'
     end
   end
 
-  describe "symlink" do
+  describe 'rc' do
-    let(:castle) { given_castle("glencairn") }
+    let(:castle) { given_castle('glencairn') }
 
-    it "links dotfiles from a castle to the home folder" do
+    context 'when told to do so' do
-      dotfile = castle.file(".some_dotfile")
+      before do
-
+        expect($stdout).to receive(:print)
-      homesick.symlink("glencairn")
+        expect($stdin).to receive(:gets).and_return('y')
-
-      home.join(".some_dotfile").readlink.should == dotfile
       end
 
-    it "links non-dotfiles from a castle to the home folder" do
+      it 'executes the .homesickrc' do
-      dotfile = castle.file("bin")
+        castle.file('.homesickrc') do |file|
-
+          file << "File.open(Dir.pwd + '/testing', 'w') { |f| f.print 'testing' }"
-      homesick.symlink("glencairn")
-
-      home.join("bin").readlink.should == dotfile
         end
 
-    context "when forced" do
+        homesick.rc castle
+
+        castle.join('testing').should exist
+      end
+    end
+
+    context 'when told not to do so' do
+      before do
+        expect($stdout).to receive(:print)
+        expect($stdin).to receive(:gets).and_return('n')
+      end
+
+      it 'does not execute the .homesickrc' do
+        castle.file('.homesickrc') do |file|
+          file << "File.open(Dir.pwd + '/testing', 'w') { |f| f.print 'testing' }"
+        end
+
+        homesick.rc castle
+
+        castle.join('testing').should_not exist
+      end
+    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
+      it 'can override symlinks to directories' do
         somewhere_else = create_construct
-        existing_dotdir_link = home.join(".vim")
+        existing_dotdir_link = home.join('.vim')
         FileUtils.ln_s somewhere_else, existing_dotdir_link
 
-        dotdir = castle.directory(".vim")
+        dotdir = castle.directory('.vim')
 
-        homesick.symlink("glencairn")
+        homesick.symlink('glencairn')
 
         existing_dotdir_link.readlink.should == dotdir
       end
+
+      it 'can override existing directory' do
+        existing_dotdir = home.directory('.vim')
+
+        dotdir = castle.directory('.vim')
+
+        homesick.symlink('glencairn')
+
+        existing_dotdir.readlink.should == dotdir
+      end
     end
 
     context "with '.config' in .homesick_subdir" do
-      let(:castle) { given_castle("glencairn", [".config"]) }
+      let(:castle) { given_castle('glencairn', ['.config']) }
-      it "can symlink in sub directory" do
+      it 'can symlink in sub directory' do
-        dotdir = castle.directory(".config")
+        dotdir = castle.directory('.config')
-        dotfile = dotdir.file(".some_dotfile")
+        dotfile = dotdir.file('.some_dotfile')
 
-        homesick.symlink("glencairn")
+        homesick.symlink('glencairn')
 
-        home_dotdir = home.join(".config")
+        home_dotdir = home.join('.config')
-        home_dotdir.symlink?.should == false
+        home_dotdir.symlink?.should be == false
-        home_dotdir.join(".some_dotfile").readlink.should == dotfile
+        home_dotdir.join('.some_dotfile').readlink.should == dotfile
       end
     end
 
     context "with '.config/appA' in .homesick_subdir" do
-      let(:castle) { given_castle("glencairn", [".config/appA"]) }
+      let(:castle) { given_castle('glencairn', ['.config/appA']) }
-      it "can symlink in nested sub directory" do
+      it 'can symlink in nested sub directory' do
-        dotdir = castle.directory(".config").directory("appA")
+        dotdir = castle.directory('.config').directory('appA')
-        dotfile = dotdir.file(".some_dotfile")
+        dotfile = dotdir.file('.some_dotfile')
 
-        homesick.symlink("glencairn")
+        homesick.symlink('glencairn')
 
-        home_dotdir = home.join(".config").join("appA")
+        home_dotdir = home.join('.config').join('appA')
-        home_dotdir.symlink?.should == false
+        home_dotdir.symlink?.should be == false
-        home_dotdir.join(".some_dotfile").readlink.should == dotfile
+        home_dotdir.join('.some_dotfile').readlink.should == dotfile
       end
     end
 
-    context "with '.config' and '.config/appA' in .homesick_subdir" do
+    context "with '.config' and '.config/someapp' in .homesick_subdir" do
-      let(:castle) { given_castle("glencairn", [".config", ".config/appA"]) }
+      let(:castle) { given_castle('glencairn', ['.config', '.config/someapp']) }
-      it "can symlink under both of .config and .config/appA" do
+      it 'can symlink under both of .config and .config/someapp' do
-        config_dir = castle.directory(".config")
+        config_dir = castle.directory('.config')
-        config_dotfile = config_dir.file(".some_dotfile")
+        config_dotfile = config_dir.file('.some_dotfile')
-        appA_dir = config_dir.directory("appA")
+        someapp_dir = config_dir.directory('someapp')
-        appA_dotfile = appA_dir.file(".some_appfile")
+        someapp_dotfile = someapp_dir.file('.some_appfile')
 
-        homesick.symlink("glencairn")
+        homesick.symlink('glencairn')
 
-        home_config_dir = home.join(".config")
+        home_config_dir = home.join('.config')
-        home_appA_dir = home_config_dir.join("appA")
+        home_someapp_dir = home_config_dir.join('someapp')
-        home_config_dir.symlink?.should == false
+        home_config_dir.symlink?.should be == false
-        home_config_dir.join(".some_dotfile").readlink.should == config_dotfile
+        home_config_dir.join('.some_dotfile').readlink.should be == config_dotfile
-        home_appA_dir.symlink?.should == false
+        home_someapp_dir.symlink?.should be == false
-        home_appA_dir.join(".some_appfile").readlink.should == appA_dotfile
+        home_someapp_dir.join('.some_appfile').readlink.should == someapp_dotfile
+      end
+    end
+
+    context "when call with no castle name" do
+      let(:castle) { given_castle('dotfiles') }
+      it 'using default castle name: "dotfiles"' do
+        dotfile = castle.file('.some_dotfile')
+
+        homesick.symlink
+
+        home.join('.some_dotfile').readlink.should == dotfile
       end
     end
   end
 
-  describe "list" do
+  describe 'unlink' do
-    it "should say each castle in the castle directory" do
+    let(:castle) { given_castle('glencairn') }
+
+    it 'unlinks dotfiles in the home folder' do
+      castle.file('.some_dotfile')
+
+      homesick.symlink('glencairn')
+      homesick.unlink('glencairn')
+
+      home.join('.some_dotfile').should_not exist
+    end
+
+    it 'unlinks non-dotfiles from the home folder' do
+      castle.file('bin')
+
+      homesick.symlink('glencairn')
+      homesick.unlink('glencairn')
+
+      home.join('bin').should_not exist
+    end
+
+    context "with '.config' in .homesick_subdir" do
+      let(:castle) { given_castle('glencairn', ['.config']) }
+
+      it 'can unlink sub directories' do
+        castle.directory('.config').file('.some_dotfile')
+
+        homesick.symlink('glencairn')
+        homesick.unlink('glencairn')
+
+        home_dotdir = home.join('.config')
+        home_dotdir.should exist
+        home_dotdir.join('.some_dotfile').should_not exist
+      end
+    end
+
+    context "with '.config/appA' in .homesick_subdir" do
+      let(:castle) { given_castle('glencairn', ['.config/appA']) }
+
+      it 'can unsymlink in nested sub directory' do
+        castle.directory('.config').directory('appA').file('.some_dotfile')
+
+        homesick.symlink('glencairn')
+        homesick.unlink('glencairn')
+
+        home_dotdir = home.join('.config').join('appA')
+        home_dotdir.should exist
+        home_dotdir.join('.some_dotfile').should_not exist
+      end
+    end
+
+    context "with '.config' and '.config/someapp' in .homesick_subdir" do
+      let(:castle) { given_castle('glencairn', ['.config', '.config/someapp']) }
+
+      it 'can unsymlink under both of .config and .config/someapp' do
+        config_dir = castle.directory('.config')
+        config_dir.file('.some_dotfile')
+        config_dir.directory('someapp').file('.some_appfile')
+
+        homesick.symlink('glencairn')
+        homesick.unlink('glencairn')
+
+        home_config_dir = home.join('.config')
+        home_someapp_dir = home_config_dir.join('someapp')
+        home_config_dir.should exist
+        home_config_dir.join('.some_dotfile').should_not exist
+        home_someapp_dir.should exist
+        home_someapp_dir.join('.some_appfile').should_not exist
+      end
+    end
+
+    context "when call with no castle name" do
+      let(:castle) { given_castle('dotfiles') }
+
+      it 'using default castle name: "dotfiles"' do
+        castle.file('.some_dotfile')
+
+        homesick.symlink
+        homesick.unlink
+
+        home.join('.some_dotfile').should_not exist
+      end
+    end
+  end
+
+  describe 'list' do
+    it 'should say each castle in the castle directory' do
       given_castle('zomg')
       given_castle('wtf/zomg')
 
-      homesick.should_receive(:say_status).with("zomg", "git://github.com/technicalpickles/zomg.git", :cyan)
+      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.should_receive(:say_status).with('wtf/zomg', 'git://github.com/technicalpickles/zomg.git', :cyan)
 
       homesick.list
     end
   end
 
-  describe "pull" do
+  describe 'status' do
 
-    xit "needs testing"
+    xit 'needs testing'
 
-    describe "--all" do
+  end
-      xit "needs testing"
+
+  describe 'diff' do
+
+    xit 'needs testing'
+
+  end
+
+  describe 'show_path' do
+    it 'should say the path of a castle' do
+      castle = given_castle('castle_repo')
+
+      homesick.should_receive(:say).with(castle.dirname)
+
+      homesick.show_path('castle_repo')
+    end
+  end
+
+  describe 'pull' do
+
+    xit 'needs testing'
+
+    describe '--all' do
+      xit 'needs testing'
     end
 
   end
 
-  describe "commit" do
+  describe 'commit' do
 
-    xit "needs testing"
+    xit 'needs testing'
 
   end
 
-  describe "push" do
+  describe 'push' do
 
-    xit "needs testing"
+    xit 'needs testing'
 
   end
 
-  describe "track" do
+  describe 'track' do
-    it "should move the tracked file into the castle" 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 = castle.join('.some_rc_file')
       tracked_file.should exist
 
       some_rc_file.readlink.should == tracked_file
@@ -239,7 +419,22 @@ describe "homesick" do
       some_nested_dir.realpath.should == tracked_file.realpath
     end
 
-    describe "subdir_file" do
+    context "when call with no castle name" do
+      it 'using default castle name: "dotfiles"' do
+        castle = given_castle('dotfiles')
+
+        some_rc_file = home.file '.some_rc_file'
+
+        homesick.track(some_rc_file.to_s)
+
+        tracked_file = castle.join('.some_rc_file')
+        tracked_file.should exist
+
+        some_rc_file.readlink.should == tracked_file
+      end
+    end
+
+    describe 'subdir_file' do
 
       it 'should add the nested files parent to the subdir_file' do
         castle = given_castle('castle_repo')

spec/spec_helper.rb

@@ -16,19 +16,19 @@ RSpec.configure do |config|
     homesick.stub(:say_status)
   end
 
-  def given_castle(path, subdirs=[])
+  def given_castle(path, subdirs = [])
     name = Pathname.new(path).basename
     castles.directory(path) do |castle|
       Dir.chdir(castle) do
-        system "git init >/dev/null 2>&1"
+        system 'git init >/dev/null 2>&1'
         system "git remote add origin git://github.com/technicalpickles/#{name}.git >/dev/null 2>&1"
-        if subdirs then
+        if subdirs
           subdir_file = castle.join(Homesick::SUBDIR_FILENAME)
           subdirs.each do |subdir|
             system "echo #{subdir} >> #{subdir_file}"
           end
         end
-        return castle.directory("home")
+        return castle.directory('home')
       end
     end
   end