Regenerated gemspec for version 0.5.2

ChangeLog.markdown

@@ -1,4 +1,26 @@
-# 2.0.0
+# 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
@@ -12,6 +34,6 @@
  * Fixed linking, which tries to exclude . and .. from the list of files to
  link (thanks Martinos!)
 
- # 0.1.0
+# 0.1.0
 
  * Initial release

Gemfile

@@ -1,7 +1,7 @@
 # Add dependencies required to use your gem here.
 group :runtime do
   #gem 'bundler', '>= 0.9.5'
-  gem "thor"
+  gem "thor", ">= 0.13.6"
 end
 
 # Add dependencies to develop your gem here.
@@ -12,5 +12,5 @@ group :development do
   gem "bundler", ">= 0.9.5"
   gem "jeweler", ">= 1.4.0"
   gem "rcov", ">= 0"
-  gem "devver-construct"
+  gem "test-construct"
 end

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,21 @@ 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 uou 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
+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 +45,6 @@ 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
+## Copyright
 
 Copyright (c) 2010 Joshua Nichols. See LICENSE for details.

Rakefile

@@ -22,7 +22,7 @@ Jeweler::Tasks.new do |gem|
   gem.email = "josh@technicalpickles.com"
   gem.homepage = "http://github.com/technicalpickles/homesick"
   gem.authors = ["Joshua Nichols"]
-  gem.version = "0.2.0"
+  gem.version = "0.5.2"
   # Have dependencies? Add them to Gemfile
 
   # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings

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

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{homesick}
-  s.version = "0.2.0"
+  s.version = "0.5.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joshua Nichols"]
-  s.date = %q{2010-03-19}
+  s.date = %q{2010-07-22}
   s.default_executable = %q{homesick}
   s.description = %q{
     A man’s home (directory) is his castle, so don’t leave home with out it.
@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = [
     "ChangeLog.markdown",
      "LICENSE",
-     "README.rdoc"
+     "README.markdown"
   ]
   s.files = [
     ".document",
@@ -30,14 +30,14 @@ Gem::Specification.new do |s|
      "ChangeLog.markdown",
      "Gemfile",
      "LICENSE",
-     "README.rdoc",
+     "README.markdown",
      "Rakefile",
      "bin/homesick",
      "homesick.gemspec",
      "lib/homesick.rb",
      "lib/homesick/actions.rb",
      "lib/homesick/shell.rb",
-     "spec/homesick/homesick_spec.rb",
+     "spec/homesick_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
   ]
@@ -47,7 +47,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{A man's home is his castle. Never leave your dotfiles behind.}
   s.test_files = [
-    "spec/homesick/homesick_spec.rb",
+    "spec/homesick_spec.rb",
      "spec/spec_helper.rb"
   ]
 

lib/homesick.rb

@@ -9,7 +9,7 @@ class Homesick < Thor
 
   add_runtime_options!
 
-  GITHUB_NAME_REPO_PATTERN = /\A([A-Za-z_-]+)\/([A-Za-z_-]+)\Z/
+  GITHUB_NAME_REPO_PATTERN = /\A([A-Za-z_-]+\/[A-Za-z_-]+)\Z/
 
   def initialize(args=[], options={}, config={})
     super
@@ -18,75 +18,113 @@ class Homesick < Thor
 
   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 =~ GITHUB_NAME_REPO_PATTERN
+      destination = nil
-        git_clone "git://github.com/#{$1}/#{$2}.git", :destination => "#{$1}_#{$2}"
+      if File.exist?(uri)
+        destination = Pathname.new(uri).basename
+
+        ln_s uri, destination
+      elsif uri =~ GITHUB_NAME_REPO_PATTERN
+        destination = Pathname.new($1)
+        git_clone "git://github.com/#{$1}.git", :destination => destination
       else
+        if uri =~ /\/([^\/]*).git\Z/
+          destination = Pathname.new($1)
+        end
+
         git_clone uri
       end
+
+      if destination.join('.gitmodules').exist?
+        inside destination do
+          git_submodule_init
+          git_submodule_update
+        end
+      end
     end
   end
 
-  desc "link NAME", "Symlinks all dotfiles from the specified castle"
+  desc "pull NAME", "Update the specified castle"
-  def link(home)
+  def pull(name)
-    unless castle_dir(home).exist?
+    check_castle_existance(name, "pull")
-      say_status :error, "Castle #{home} did not exist in #{repos_dir}", :red
 
-      exit(1)
+    inside repos_dir.join(name) do
+      git_pull
+      git_submodule_init
+      git_submodule_update
+    end
+  end
 
-    else
+  desc "symlink NAME", "Symlinks all dotfiles from the specified castle"
-      inside castle_dir(home) do
+  def symlink(name)
-        files = Pathname.glob('.*').reject{|a| [".",".."].include?(a.to_s)}
+    check_castle_existance(name, "symlink")
-        files.each do |path|
-          absolute_path = path.expand_path
 
-          inside user_dir do
+    inside castle_dir(name) do
-            adjusted_path = (user_dir + path).basename
+      files = Pathname.glob('.*').reject{|a| [".",".."].include?(a.to_s)}
+      files.each do |path|
+        absolute_path = path.expand_path
 
-            symlink absolute_path, adjusted_path
+        inside home_dir do
-          end
+          adjusted_path = (home_dir + path).basename
+
+          ln_s absolute_path, adjusted_path
         end
       end
     end
-
   end
 
   desc "list", "List cloned castles"
   def list
-    inside repos_dir do
+    #require 'ruby-debug'; breakpoint
-      Pathname.glob('*') do |home|
+    Pathname.glob("#{repos_dir}/**/*/.git") do |git_dir|
-        inside home do
+      castle = git_dir.dirname
-          say_status home, `git config remote.origin.url`, :cyan
+      Dir.chdir castle do # so we can call git config from the right contxt
-        end
+        say_status castle.relative_path_from(repos_dir), `git config remote.origin.url`.chomp, :cyan
       end
     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
+    github_user = `git config github.user`.chomp
-    # class method, so it's convenient to stub out during tests
+    github_user = nil if github_user == ""
-    def self.user_dir
+    github_repo = castle.basename
-      @user_dir ||= Pathname.new('~').expand_path
-    end
 
-    def self.repos_dir
-      @repos_dir ||= Pathname.new('~/.homesick/repos').expand_path
-    end
 
-    def repos_dir
+    empty_directory castle
-      self.class.repos_dir
+    inside castle do
+      git_init
+      if github_user
+        url = "git@github.com:#{github_user}/#{github_repo}.git"
+        git_remote_add 'origin', url
+      end
+
+      empty_directory "home"
     end
   end
 
   protected
 
-  def user_dir
+  def home_dir
-    self.class.user_dir
+    @home_dir ||= Pathname.new(ENV['HOME'] || '~').expand_path
+  end
+
+  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
+
 end

lib/homesick/actions.rb

@@ -5,10 +5,11 @@ class Homesick
       config ||= {}
       destination = config[:destination] || begin
         repo =~ /([^\/]+)\.git$/
-          $1
+       $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]
@@ -18,7 +19,48 @@ class Homesick
       end
     end
 
-    def symlink(source, destination, config = {})
+    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 >/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 ln_s(source, destination, config = {})
+      source = Pathname.new(source)
       destination = Pathname.new(destination)
 
       if destination.symlink?
@@ -31,6 +73,12 @@ class Homesick
             system "ln -sf #{source} #{destination}" unless options[:pretend]
           end
         end
+      elsif destination.exist?
+        say_status :conflict, "#{destination} exists", :red unless options[:quiet]
+
+        if 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]

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,71 @@
+require 'spec_helper'
+
+describe Homesick do
+  before do
+    @homesick = Homesick.new
+  end
+
+  describe "clone" do
+    it "should symlink existing directories" do
+      somewhere = create_construct
+      somewhere.directory('wtf')
+      wtf = somewhere + 'wtf'
+
+      @homesick.should_receive(:ln_s).with(wtf.to_s, wtf.basename)
+
+      @homesick.clone wtf.to_s
+    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 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 "list" do
+
+    # FIXME only passes in isolation. need to setup data a bit better
+    xit "should say each castle in the castle directory" do
+      @user_dir.directory '.homesick/repos' do |repos_dir|
+        repos_dir.directory 'zomg' do |zomg|
+          Dir.chdir do
+            system "git init >/dev/null 2>&1"
+            system "git remote add origin git://github.com/technicalpickles/zomg.git >/dev/null 2>&1"
+          end
+        end
+
+        repos_dir.directory 'wtf/zomg' do |zomg|
+          Dir.chdir do
+            system "git init >/dev/null 2>&1"
+            system "git remote add origin git://github.com/technicalpickles/zomg.git >/dev/null 2>&1"
+          end
+        end
+      end
+
+      @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
+end

spec/spec_helper.rb

@@ -10,7 +10,7 @@ Spec::Runner.configure do |config|
 
   config.before do
     @user_dir = create_construct
-    Homesick.stub!(:user_dir).and_return(@user_dir)
+    ENV['HOME'] = @user_dir.to_s
   end
 
   config.after do