git_go 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.yardoc
+/tmp
+/pkg
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - "rbx-18mode"
+  - "rbx-19mode"
+  - "jruby-18mode"
+  - "jruby-19mode"
+script: bundle exec rspec spec
+

data/Gemfile

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "rake"
+  gem "yard"
+  gem "rspec"
+  gem "mocha"
+  gem "guard-rspec"
+  gem "rb-inotify", :require => false
+  gem "rb-fsevent", :require => false
+  gem "rb-fchange", :require => false
+  gem "growl"
+end
+

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    git_go (0.0.1)
+      net-ssh (~> 2.6.2)
+      thor (~> 0.16.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.0.8)
+    diff-lcs (1.1.3)
+    ffi (1.2.0)
+    growl (1.0.3)
+    guard (1.5.4)
+      listen (>= 0.4.2)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-rspec (2.3.1)
+      guard (>= 1.1)
+      rspec (~> 2.11)
+    listen (0.6.0)
+    lumberjack (1.0.2)
+    metaclass (0.0.1)
+    method_source (0.8.1)
+    mocha (0.13.1)
+      metaclass (~> 0.0.1)
+    net-ssh (2.6.2)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rake (10.0.2)
+    rb-fchange (0.0.5)
+      ffi
+    rb-fsevent (0.9.2)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.1)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+    slop (3.3.3)
+    thor (0.16.0)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  git_go!
+  growl
+  guard-rspec
+  mocha
+  rake
+  rb-fchange
+  rb-fsevent
+  rb-inotify
+  rspec
+  yard

data/Guardfile

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+
+guard "rspec" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch("spec/spec_helper.rb")  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michael van Rooijen
+
+MIT License
+
+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,50 @@
+# Git Go
+
+[![Build Status](https://travis-ci.org/meskyanichi/git_go.png)](https://travis-ci.org/meskyanichi/git_go)
+
+Git Go is a small command-line utility distributed as a RubyGem that allows you to easily create/destroy/rename/list all your private-hosted git repositories on your own server. All you need is a small VPS (256MB RAM / 10GB HDD / 1vCPUCore should be sufficient).
+
+Git Go also provides you with detailed instructions on how to set up your server in order to be able to create remote repositories from your local machine using the provided command-line utility. The instructions also show you how to set up automatic/daily compressed/archived backups of all your git repositories, store them on Amazon S3, cycle them and send you success/error notifications by email, all using the [Backup](http://github.com/meskyanichi/backup) RubyGem. It's easy, and only takes a few minutes to set up.
+
+## Get Git Go
+
+Install Git Go with the following command:
+
+```sh
+gem install git_go
+```
+
+This will provide you with the `gg` executable. Simply run it without any arguments to see the list of tasks it can perform.
+
+```sh
+$ gg
+
+Tasks:
+  gg create NAME           # Create a new remote repository named NAME
+  gg destroy NAME          # Destroy the remote repository named NAME
+  gg help [TASK]           # Describe available tasks or one specific task
+  gg instructions          # Display a detailed guide to setup Git Go locally and remotely
+  gg list                  # Display a list of all the remote repositories and their URL
+  gg rename NAME NEW_NAME  # Rename the remote repository named NAME to NEW_NAME
+```
+
+I recommend you run `gg instructions` to get up and running. The instructions cover:
+
+* Setting up two local environment variables in your .bashrc or .zshrc.
+* Adding a git user to your remote machine.
+* Setting up SSH keys.
+* Setting up the Backup RubyGem to perform daily backups with:
+  * GZip Compression
+  * Email Notification on success/warning/error
+  * Amazon S3 storage
+  * Cycling (e.g. 30 day backup retention, then pop old backups for new backups)
+
+
+## License
+
+"Git Go" is released under the MIT License. See `LICENSE`.
+
+## Author
+
+Michael van Rooijen | [@meskyanichi](http://twitter.com/meskyanichi) | http://github.com/meskyanichi
+

data/Rakefile

@@ -0,0 +1,3 @@
+# -*- encoding : utf-8 -*-
+require "bundler/gem_tasks"
+

data/assets/instructions

@@ -0,0 +1,164 @@
+
+GIT GO INSTRUCTIONS
+===================
+
+http://github.com/meskyanichi/git_go
+
+Here are the instructions for getting your environments set up.
+
+Local Environment
+-----------------
+
+Add the following to your .bashrc or .zshrc file:
+
+  export GIT_GO_USER=user
+  export GIT_GO_HOST=host
+
+For example:
+
+  export GIT_GO_USER=git
+  export GIT_GO_HOST=repositories.example.com
+
+GIT_GO_HOST can also be a direct IP, for example:
+
+  export GIT_GO_HOST=207.97.227.239
+
+Remote Environment
+------------------
+
+The following guide assumes you are `root`. If you aren't root, prefix all commands with `sudo` or simply `sudo su` to become `root`.
+
+The guide also assumes you want a user called `git` under which we'll create all the repositories. You can substitute `git` with anything you like.
+
+Finally, the guide assumes you're using Ubuntu 12.10 as the remote machine, but this will likely work on some older versions of Ubuntu as well.
+
+Log in to your remote machine using SSH.
+Be sure you have root priviledges, either through sudo or as root.
+
+Create the "git" user:
+
+  adduser \
+    --home /home/git \
+    --shell /bin/bash \
+    --disabled-password \
+    git
+
+Create the .ssh folder and authorized_keys file for the git user.
+
+  mkdir /home/git/.ssh
+
+Now add your key (usually located in `~/.ssh/id_rsa.pub` on your local machine) to `/home/git/.ssh/authorized_keys`. Finally, fix the owner and permissions.
+
+  chmod 700 /home/git/.ssh
+  chmod 600 /home/git/.ssh/authorized_keys
+  chown -R git:git /home/git/.ssh
+
+
+Using Git Go
+------------
+
+With that, you're ready to use Git Go. Simply run `gg help` and try out any of the commands that Git Go provides.
+
+
+Backups
+-------
+
+It is always a good idea to set up backups for your git repositories. Here's a nifty and clean way to set up daily backups for all your git repositories, along with email notifications, gzip compression, Amazon S3 storing and cycling old for new backups.
+
+First, we'll need a recent version of Ruby. If Ruby isn't already installed on your machine, simply run the following:
+
+  apt-get update && apt-get upgrade -y
+  apt-get install -y python-software-properties	software-properties-common
+  apt-add-repository ppa:brightbox/ruby-ng
+  apt-get update
+  apt-get install -y ruby rubygems ruby-switch ruby1.9.3 ruby1.9.1-dev \
+    libxml2 libxslt-dev libxml2-dev libopenssl-ruby
+
+What this will do, is it will add a 3rd party repository Ruby, provided by Brightbox Systemd Ltd. It includes up-to-date Ruby versions which you can install directly through the apt package manager. After adding it and updating the repository list, we can simply install the latest 1.9.x Ruby (Ruby 1.9.3). We also include some other packages which are required for compiling certain extensions that come with the gems we'll be installing.
+
+With Ruby installed, let us set up our backup system.
+
+  gem install backup fog mail
+
+We'll be using `backup` for performing backups. We'll use `mail` with `backup` to send email notifications after each backup operation. We'll use `fog` with `backup` to send the backups to Amazon S3.
+
+Note that Backup is flexible can support a few other storage locations, including Rackspace, Dropbox, etc. The same goes for the notifier, you can use Email, Twitter or a few other notification solutions. We'll stick to mail and Amazon S3 for this guide.
+
+It is recommended that you become root before proceeding. Become root with the following command if you aren't already:
+
+  sudo su
+
+Generate the initial Backup configuration and model.
+
+  backup generate:config
+  backup generate:model --trigger gitrepositories \
+    --archives --compressors=gzip --notifiers=mail --storages=s3
+
+This should generate a configuration file in `/root/Backup/models/`. Basically what you want is the following:
+
+  Backup::Model.new(:gitrepositories, 'git repository backups') do
+    split_into_chunks_of 500
+
+    archive :git do |archive|
+      archive.add "/home/git/"
+    end
+
+    store_with S3 do |s3|
+      s3.access_key_id     = "YOUR_ACCESS_KEY_ID"
+      s3.secret_access_key = "YOUR_SECRET_ACCESS_KEY"
+      s3.region            = "us-east-1"
+      s3.bucket            = "your_bucket_name"
+      s3.path              = "/backup"
+      s3.keep              = 30
+    end
+
+    compress_with Gzip
+
+    notify_by Mail do |mail|
+      mail.on_success           = true
+      mail.on_warning           = true
+      mail.on_failure           = true
+
+      mail.from                 = "your@email.com"
+      mail.to                   = "your@email.com"
+      mail.address              = "smtp.gmail.com"
+      mail.port                 = 587
+      mail.domain               = "repositories.example.com"
+      mail.user_name            = "username@email.com"
+      mail.password             = "password"
+      mail.authentication       = "plain"
+      mail.enable_starttls_auto = true
+    end
+  end
+
+Just fill out all the settings. Once done, try it out by running:
+
+  backup perform -t gitrepositories
+
+If all goes well, you should have received an email, and the backup should have been stored on your Amazon S3 account in the specified bucket under /backups.
+
+Check out https://github.com/meskyanichi/backup for more information.
+
+Now let's set up cron to automatically invoke this command every day. First, check to see where exactly backup has been installed on your machine.
+
+  which backup
+
+You'll likely see the following:
+
+  /usr/local/bin/backup
+
+Copy this path and we'll use it in the crontab. Edit the crontab by running:
+
+  crontab -e
+
+Add this line to the crontab:
+
+  0 0 * * * /bin/bash -l -c '/usr/local/bin/backup perform -t gitrepositories'
+
+Save and close. Now you should have set up daily backups of your entire /home/git directory. This is nice because if you experience any data loss due to for example hardware failures, just spin up or reset the server, create the git user again and simply extract the `git.tar.gz` to the `/home/git` directory to restore all your repositories and ssh configuration.
+
+
+Michael van Rooijen
+> http://github.com/meskyanichi
+> http://twitter.com/meskyanichi
+

data/bin/gg

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+# -*- encoding : utf-8 -*-
+
+$: << File.expand_path("../../lib", __FILE__)
+
+require "git_go"
+require "git_go/cli/gg"
+
+GitGo::Repository.start
+

data/gitgo.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "git_go/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "git_go"
+  gem.version       = GitGo::VERSION
+  gem.authors       = ["Michael van Rooijen"]
+  gem.email         = ["meskyanichi@gmail.com"]
+  gem.description   = %q{Git Go is a small command-line utility distributed as a RubyGem that allows you to easily create/destroy/rename/list all your private-hosted git repositories on your own server.}
+  gem.summary       = gem.description
+  gem.homepage      = "http://github.com/meskyanichi/git_go"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "thor",    ["~> 0.16.0"]
+  gem.add_dependency "net-ssh", ["~> 2.6.2"]
+end
+

data/lib/git_go/cli/gg.rb

@@ -0,0 +1,120 @@
+# -*- encoding : utf-8 -*-
+
+module GitGo
+  class Repository < Thor
+    include Thor::Actions
+
+    desc "create NAME", "Create a new remote repository named NAME"
+    def create(name)
+      core = GitGo::Core.new
+      conn = core.connection
+      if conn.directory?("#{name}.git")
+        puts "'#{name}' already exists."
+        conn.close_and_exit(1)
+      else
+        conn.mkdir("#{name}.git")
+        conn.cd("#{name}.git")
+        response = conn.bash("git init --bare")
+
+        if response[:exit_code] == 0
+          puts "Repository created at: #{core.user}@#{core.host}:#{name}.git"
+        else
+          puts "Failed to create repository."
+          puts response[:stderr] + response[:stdout]
+        end
+      end
+
+      conn.close
+    end
+
+    desc "destroy NAME", "Destroy the remote repository named NAME"
+    def destroy(name)
+      core = GitGo::Core.new
+      conn = core.connection
+      repository = "#{name}.git"
+      if conn.directory?(repository)
+        if yes?("Are you sure you want to destroy '#{name}'?")
+          response = conn.rm(repository)
+          if response[:exit_code] == 0
+            puts "Repository '#{name}' was destroyed."
+          else
+            puts "Repository '#{name}' could not be destroyed."
+            puts response[:stdout] + response[:stderr]
+            conn.close_and_exit(1)
+          end
+        end
+      else
+        puts "Repository '#{name}' does not exist."
+        conn.close_and_exit(1)
+      end
+
+      conn.close
+    end
+
+    desc "rename NAME NEW_NAME", "Rename the remote repository named NAME to NEW_NAME"
+    def rename(name, new_name)
+      core           = GitGo::Core.new
+      conn           = core.connection
+      repository     = "#{name}.git"
+      new_repository = "#{new_name}.git"
+
+      if not conn.directory?(repository)
+        puts "Repository '#{name}' does not exist."
+        conn.close_and_exit(1)
+      end
+
+      if conn.directory?(new_repository)
+        puts "Repository '#{new_name}' already exists."
+        conn.close_and_exit(1)
+      end
+
+      response = conn.mv(repository, new_repository)
+      if response[:exit_code] == 0
+        puts "Repository '#{name}' renamed to '#{new_name}'."
+      else
+        puts "Could not rename '#{name}' to '#{new_name}'."
+        puts response[:stderr] + response[:stdout]
+        conn.close_and_exit(1)
+      end
+
+      conn.close
+    end
+
+    desc "list", "Display a list of all the remote repositories and their URL"
+    def list
+      core = GitGo::Core.new
+      conn = core.connection
+
+      response = conn.bash("find ./*.git/ -mindepth 0 -maxdepth 0")
+
+      if response[:exit_code] == 0
+        repositories = response[:stdout].split("\n").map { |r| File.basename(r) }
+        list = [["Repository", "Git Fetch/Push URL"]]
+
+        repositories.each do |repository|
+          list << [
+            repository.sub(".git", ""),
+            "#{core.user}@#{core.host}:#{repository}"
+          ]
+        end
+
+        amount = list.count - 1
+        out    = Formatter.columns(list, :spacing => 4, :header => true)
+
+        puts "\n" + out
+        puts "\nThere #{amount == 1 ? "is" : "are"} #{amount} git " +
+          "#{amount == 1 ? "repository" : "repositories"}.\n"
+      else
+        puts "There are no repositories at #{core.user}@#{core.host}."
+      end
+
+      conn.close
+    end
+
+    desc "instructions", "Display a detailed guide to setup Git Go locally and remotely"
+    def instructions
+      puts Core.instructions
+    end
+  end
+end
+

data/lib/git_go/connection.rb

@@ -0,0 +1,139 @@
+# -*- encoding : utf-8 -*-
+
+module GitGo
+  class Connection
+
+    # @return [GitGo::Core] instance.
+    attr_reader :core
+
+    # @return [Net::SSH::Connection::Session] instance.
+    attr_reader :ssh
+
+    # @return [String] the current path on the host.
+    attr_reader :current_path
+
+    # Creates a new instane of GitGo::Connection. Establishes
+    # a session with the host and stores that session in #ssh.
+    #
+    # @param [GitGo::Core] core takes and assigns a reference to parent class in #core.
+    # @return [GitGo::Connection] an instance of GitGo::Connection.
+    def initialize(core)
+      @core         = core
+      @ssh          = Net::SSH.start(core.host, core.user)
+      @current_path = ""
+    end
+
+    # Moves the session to the provided path and remembers it for the next
+    # action performed through the #bash method. It keeps the current path
+    # in #current_path
+    #
+    # @see #bash
+    # @see #current_path
+    # @param [String] path the path to navigate to.
+    # @return [String] the new path.
+    def cd(path)
+      @current_path = bash("cd '#{current_path}'; cd '#{path}'; pwd")[:stdout].chomp
+    end
+
+    # Tests to see whether the provided path is a directory.
+    # It will take the path relative from #current_path if no absolute
+    # path was provided.
+    #
+    # @param [String] path the path to test.
+    # @return [true, false]
+    def directory?(path)
+      bash("[ -d '#{path}' ]")[:exit_code] == 0
+    end
+
+    # Tests to see whether the provided path is a file.
+    # It will take the path relative from #current_path if no absolute
+    # path was provided.
+    #
+    # @param [String] path the path to test.
+    # @return [true, false]
+    def file?(path)
+      bash("[ -f '#{path}' ]")[:exit_code] == 0
+    end
+
+    # Creates a directory at the provided path.
+    # It will take the path relative from #current_path if no absolute
+    # path was provided.
+    #
+    # @param [String] path the path to create one or more directories for.
+    # @return [Hash] containing #bash response data.
+    def mkdir(path)
+      bash("mkdir -p '#{path}'")
+    end
+
+    # Removes a file or directory at the provided path.
+    # It will take the path relative from #current_path if no absolute
+    # path was provided.
+    #
+    # @param [String] path the path to the file or directory to remove.
+    # @return [Hash] containing #bash response data.
+    def rm(path)
+      bash("rm -rf '#{path}'")
+    end
+
+    # Moves a file or directory from the provided path to the newly specified path.
+    # It will take the path relative from #current_path if no absolute
+    # path was provided.
+    #
+    # @param [String] path the path to the file or directory to move.
+    # @param [String] new_path the path to where the new file or directory should be placed.
+    # @return [Hash] containing #bash response data.
+    def mv(path, new_path)
+      bash("mv '#{path}' '#{new_path}'")
+    end
+
+    # Closes the #ssh connection and clears the `@connection` instance
+    # variable of this objects parent `Core` instance so new connections
+    # can be established.
+    def close
+      ssh.close
+      core.clear_connection
+    end
+
+    # Closes the #ssh connection and exits the program with CODE.
+    #
+    # @see #close
+    # @param [Integer] code the code to exit the program with.
+    def close_and_exit(code = 0)
+      close
+      exit(code)
+    end
+
+    # Opens a channel for the #ssh connection and executes the provided COMMAND.
+    # This is a blocking (non-asynchronous) operation.
+    #
+    # @param [String] command the command to perform on the host.
+    # @return [Hash] containing response data (:stdout, :stderr, :exit_code, :exit_signal).
+    def bash(command)
+      stdout_data = ""
+      stderr_data = ""
+      exit_code   = nil
+      exit_signal = nil
+
+      ssh.open_channel do |channel|
+        channel.exec("cd '#{current_path}'; #{command}") do |ch, success|
+          abort "FAILED: couldn't execute command (ssh.channel.exec)" unless success
+
+          channel.on_data                   { |ch,data| stdout_data += data          }
+          channel.on_extended_data          { |ch,type,data| stderr_data += data     }
+          channel.on_request("exit-status") { |ch,data| exit_code = data.read_long   }
+          channel.on_request("exit-signal") { |ch, data|exit_signal = data.read_long }
+        end
+      end
+
+      ssh.loop
+
+      {
+        :stdout      => stdout_data,
+        :stderr      => stderr_data,
+        :exit_code   => exit_code,
+        :exit_signal => exit_signal
+      }
+    end
+  end
+end
+

data/lib/git_go/formatter.rb

@@ -0,0 +1,55 @@
+# -*- encoding : utf-8 -*-
+
+module GitGo
+  class Formatter
+
+    # Creates a nice column format to output an Array to the console.
+    #
+    # @param [Array] array the Array to output in a column format.
+    # @param [Hash] options the options to create the column format with.
+    # @option options [Integer] :spacing (4) the amount of spaces between the columns.
+    # @option options [true, false] :header (false) whether there is a header present or not.
+    # @return [String] the formatted Array.
+    def self.columns(array, options = {})
+      options[:spacing] ||= 4
+      options[:header]  ||= false
+
+      columns        = 1
+      column_lengths = []
+      out            = ""
+
+      array.each { |row| columns = row.length if row.length > columns }
+
+      columns.times do |i|
+        array.each do |row|
+          column_lengths[i] ||= 0
+          column_lengths[i] = row[i].length if row[i].length > column_lengths[i]
+        end
+      end
+
+      array.each_with_index do |row, row_index|
+        row.each_with_index do |column, index|
+          column_spacing = index + 1 == columns ? 0 : options[:spacing]
+          fill           = column_lengths[index] - column.length
+
+          out << column + " " * (fill + column_spacing)
+          out << "\n" if index + 1 == columns
+        end
+
+        if options[:header]
+          row.each_with_index do |column, index|
+            if row_index == 0
+              column_spacing = index + 1 == columns ? 0 : options[:spacing]
+              out << "-" * column_lengths[index] + " " * column_spacing
+            end
+
+            out << "\n" if index + 1 == columns && row_index == 0
+          end
+        end
+      end
+
+      out
+    end
+  end
+end
+

data/lib/git_go/version.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+
+module GitGo
+
+  # @return [String] the current GitGo version.
+  VERSION = "0.0.1"
+end
+

data/lib/git_go.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+
+require "rubygems"
+require "thor"
+require "net/ssh"
+
+require "git_go/connection"
+require "git_go/formatter"
+require "git_go/version"
+
+module GitGo
+  class Core
+
+    # @return [String] the user for the #host.
+    attr_reader :user
+
+    # @return [String] the host/domain/ip of the remote machine.
+    attr_reader :host
+
+    # Creates a new instance of GitGo::Core. Will exit(1)
+    # the program if GIT_GO_USER or GIT_GO_HOST environment
+    # variables aren't present.
+    #
+    # @return [GitGo::Core] an instance of GitGo::Core
+    def initialize
+      @user = ENV["GIT_GO_USER"]
+      @host = ENV["GIT_GO_HOST"]
+
+      if [user, host].include?(nil)
+        puts "GIT_GO_USER and GIT_GO_HOST not set."
+        puts "Run `gg instructions` for more details."
+        exit(1)
+      end
+    end
+
+    # Creates and returns a new instance of GitGo::Connection.
+    # Subsequent calls to this method will returned the same cached
+    # reference to the previously created instance.
+    #
+    # @return [GitGo::Connection] an instance of GitGo::Connection
+    def connection
+      @connection ||= Connection.new(self)
+    end
+
+    # Clears a previously established connection reference. After
+    # invoking this method, it is again possible to establish a new
+    # connection with the remote machine using #connection.
+    #
+    # @see #connection
+    # @return [nil]
+    def clear_connection
+      @connection = nil
+    end
+
+    # Prints installation instructions to the console.
+    def self.instructions
+      file = File.expand_path("../../assets/instructions", __FILE__)
+      File.read(file)
+    end
+  end
+end
+

data/spec/lib/git_go/connection_spec.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+
+require "spec_helper"
+
+describe GitGo::Connection do
+
+  let(:core) { GitGo::Core.new             }
+  let(:conn) { GitGo::Connection.new(core) }
+  let(:ssh)  { mock("Net::SSH")            }
+
+  before do
+    ENV["GIT_GO_USER"] = "git"
+    ENV["GIT_GO_HOST"] = "127.0.0.1"
+    Net::SSH.stubs(:start).returns(ssh)
+  end
+
+  it("test if propperly mocked") { core; conn; ssh }
+
+  describe "#cd" do
+    it "should update the #current_path" do
+      conn.expects(:bash).with("cd ''; cd '/some/path'; pwd").
+        returns(:stdout => "/some/path\n")
+
+      conn.cd "/some/path"
+    end
+
+    it "should travel relative from the #current_path" do
+      conn.instance_variable_set("@current_path", "/some/path")
+
+      conn.expects(:bash).with("cd '/some/path'; cd '..'; pwd").
+        returns(:stdout => "/some\n")
+
+      conn.cd ".."
+    end
+  end
+
+  describe "#directory?" do
+    it "should return true" do
+      conn.expects(:bash).with("[ -d '/some/path' ]").returns({:exit_code => 0})
+      conn.directory?("/some/path").should be_true
+    end
+
+    it "should return false" do
+      conn.expects(:bash).with("[ -d '/some/path' ]").returns({:exit_code => 1})
+      conn.directory?("/some/path").should be_false
+    end
+  end
+
+  describe "#file?" do
+    it "should return true" do
+      conn.expects(:bash).with("[ -f '/some/path' ]").returns({:exit_code => 0})
+      conn.file?("/some/path").should be_true
+    end
+
+    it "should return false" do
+      conn.expects(:bash).with("[ -f '/some/path' ]").returns({:exit_code => 1})
+      conn.file?("/some/path").should be_false
+    end
+  end
+
+  describe "#mkdir" do
+    it "should run the unix command to make a directory recursively" do
+      conn.expects(:bash).with("mkdir -p '/some/path'")
+      conn.mkdir("/some/path")
+    end
+  end
+
+  describe "#rm" do
+    it "should run the unix command to remove a file or directory recursively" do
+      conn.expects(:bash).with("rm -rf '/some/path'")
+      conn.rm("/some/path")
+    end
+  end
+
+  describe "#mv" do
+    it "should run the unix command to mv a file or directory" do
+      conn.expects(:bash).with("mv '/some/path' '/new/path'")
+      conn.mv("/some/path", "/new/path")
+    end
+  end
+
+  describe "#close" do
+    it "should close the ssh connection and unset the instance variable on `core`" do
+      ssh.expects(:close)
+
+      core.connection
+      core.instance_variable_get("@connection").should_not be_nil
+
+      conn.close
+      core.instance_variable_get("@connection").should be_nil
+    end
+  end
+
+  describe "#close_and_exit" do
+    it "should #close the connection, and #exit the program" do
+      conn.expects(:close)
+      conn.expects(:exit).with(0)
+      conn.close_and_exit
+    end
+
+    it "should #close the connection, and #exit the program" do
+      conn.expects(:close)
+      conn.expects(:exit).with(1)
+      conn.close_and_exit(1)
+    end
+  end
+end
+

data/spec/lib/git_go/formatter_spec.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+
+require "spec_helper"
+
+describe GitGo::Formatter do
+
+  describe "#columns" do
+    it "should format without a header and with 4 spaces" do
+      array = [["Column 1", "Column 2"], ["Column 10", "Column 20"]]
+      out   = GitGo::Formatter.columns(array)
+
+      out.should == (<<-EOS
+        Column 1     Column 2\s
+        Column 10    Column 20
+      EOS
+      ).gsub(/^\s+/, "")
+    end
+
+    it "should format with a header and 2 spaces" do
+      array = [
+        ["Example 1", "Example 2"],
+        ["Column 1", "Column 2"],
+        ["Column 3", "Column 4"]
+      ]
+      out = GitGo::Formatter.columns(array, :header => true, :spaces => 2)
+
+      out.should == (<<-EOS
+        Example 1    Example 2
+        ---------    ---------
+        Column 1     Column 2\s
+        Column 3     Column 4\s
+        EOS
+      ).gsub(/^\s+/, "")
+    end
+  end
+end
+

data/spec/lib/git_go/version_spec.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+
+require "spec_helper"
+
+describe GitGo::VERSION do
+  it "should be a string" do
+    GitGo::VERSION.class.should == String
+  end
+end
+

data/spec/lib/git_go_spec.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+require "spec_helper"
+
+describe GitGo do
+  it "should exit when initializing without the environment variables" do
+    ENV["GIT_GO_USER"] = nil
+    ENV["GIT_GO_HOST"] = nil
+
+    GitGo::Core.any_instance.expects(:exit).with(1)
+    GitGo::Core.any_instance.stubs(:puts)
+    GitGo::Core.new
+  end
+
+  it "should not exit when initializing with the environment variables" do
+    ENV["GIT_GO_USER"] = "git"
+    ENV["GIT_GO_HOST"] = "127.0.0.1"
+
+    GitGo::Core.any_instance.expects(:exit).never
+    GitGo::Core.new
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+
+require "git_go"
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.mock_framework = :mocha
+  config.order = "random"
+end
+

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: git_go
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Michael van Rooijen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.2
+description: Git Go is a small command-line utility distributed as a RubyGem that
+  allows you to easily create/destroy/rename/list all your private-hosted git repositories
+  on your own server.
+email:
+- meskyanichi@gmail.com
+executables:
+- gg
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- assets/instructions
+- bin/gg
+- gitgo.gemspec
+- lib/git_go.rb
+- lib/git_go/cli/gg.rb
+- lib/git_go/connection.rb
+- lib/git_go/formatter.rb
+- lib/git_go/version.rb
+- spec/lib/git_go/connection_spec.rb
+- spec/lib/git_go/formatter_spec.rb
+- spec/lib/git_go/version_spec.rb
+- spec/lib/git_go_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/meskyanichi/git_go
+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: -1366446642123636879
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1366446642123636879
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Git Go is a small command-line utility distributed as a RubyGem that allows
+  you to easily create/destroy/rename/list all your private-hosted git repositories
+  on your own server.
+test_files:
+- spec/lib/git_go/connection_spec.rb
+- spec/lib/git_go/formatter_spec.rb
+- spec/lib/git_go/version_spec.rb
+- spec/lib/git_go_spec.rb
+- spec/spec_helper.rb
+has_rdoc: