hubbard 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+/data

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2010 Matthew Foemmel
+All rights reserved.
+ 
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+ 
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+ 
+    * The names of the contributors may not be used to endorse or promote 
+      products derived from this software without specific prior written 
+      permission.
+ 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,61 @@
+Description
+===========
+
+Hubbard is a command line tool for managing shared git repositories in a team environment. It provides a security model so that users can easily control who has access to the projects they create. 
+
+Hubbard uses public SSH keys to keep track of who is executing what commands. This means you only have to create a single account on the server, instead of one per user.
+
+Hubbards was heavily inspired by gitosis, another tool for managing git repositories. However, the goal of Hubbard was to place less burden on the system administrator by allowing users to manage permissions for their own projects.
+
+How It Works
+============
+
+All comminication between users the the Hubbard server happens over SSH. Users must register their public SSH keys with the server before they can connect to it.
+
+When a user connects to the Hubbard server, the SSH daemon tries to find the user's public SSH key the "~/.ssh/authorized_keys" file on the server. That file also contains information about which user to associate with that SSH key. That information is automatically passed to the "hubbard" executable, so there is no way for users to run other programs on the server. 
+
+Installation
+===========
+
+### Server ###
+
+The first step is to create a user account called "hub" on the server machine and log into that account. You'll also need to make sure that Ruby and Rubygems are installed on the machine. You can then install hubbard like this:
+
+    $ gem install hubbard
+
+Unless you installed the gem using "sudo", the "hubbard" executable will be found somewhere under the "~/.gem" directory. You'll need to make sure this directory is included in the PATH whenever anyone uses SSH to connect. You can do this by adding the following line to the top of your "~/.bashrc" file (make sure the path matches):
+
+    export PATH=$PATH:~/.gem/ruby/1.8/bin
+
+The next step is to create an SSH keypair to access the "admin" account on the Hubbard server. You should only use this key when performing tasks that require admin access. Run this on the machine that you'll be accessing Hubbard from (i.e. your local workstation, not the server):
+
+    $ ssh-keygen -f ~/.ssh/hubadmin
+
+Now we'll need to copy the public key up to the server. Assuming that the hubbard server is named "example" :
+
+    $ cat ~/.ssh/hubadmin.pub | ssh hub@example hubbard admin add-key default
+
+On your local workstation, you can now create an alias for executing admin commands:
+
+    $ alias hubadmin='ssh -i ~/.ssh/hubadmin hub@example.com'
+
+Test the configuration:
+
+    $ hubadmin list-users
+    admin
+
+You'll probably want to create a normal (i.e. non-admin) account as described in the next section.
+
+### Client ###
+
+There is no executable to install on the client, but you will have to generate an SSH keypair and send the public key (i.e. the one that ends with ".pub") to your administrator. Your administrator will have to run the following command: 
+
+    $ cat <keyfile> | hubadmin run-as <username> add-key default
+
+Assuming your SSH keys have been set up correcly, you can simply SSH into the server machine to executable commands. You'll probably want to set up an alias to make this easier, however. For example, if your server is running at "example", you can do this:
+
+    $ alias hub='ssh hub@example'
+
+To test it, run:
+    
+    $ hub help

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "hubbard"
+    gem.summary = %Q{Hubbard is a command line tool for managing git repositories.}
+    gem.description = %Q{Hubbard is a command line tool for managing git repositories.}
+    gem.email = "git@foemmel.com"
+    gem.homepage = "http://github.com/mfoemmel/hubbard"
+    gem.authors = ["Matthew Foemmel"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.files << Dir['commands/*.rb']
+    gem.bindir = 'bin'
+    gem.executables << 'hubbard'
+    gem.require_path = ''
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hubbard #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/hubbard

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+PROJECT_REGEX='[a-zA-Z0-9\-]{1,32}'
+REPOSITORY_REGEX='[a-zA-Z0-9\-]{1,32}'
+USERNAME_REGEX='[a-zA-Z0-9\-]{1,32}'
+
+HUB_DATA=ENV['HUB_DATA'] || File.expand_path("~/.hubbard")
+
+FileUtils.mkdir_p(File.join(HUB_DATA, "projects"))
+FileUtils.mkdir_p(File.join(HUB_DATA, "accounts"))
+
+def next_arg(msg)
+  if ARGV.length < 1
+    $stderr.puts msg
+    exit 1
+  end
+  ARGV.shift
+end
+
+def check_status(msg)
+  if $!.exitstatus != 0
+    $sderr.puts msg
+    exit 1
+  end
+end
+
+def validate_project_name(name)
+  if name !~ /#{PROJECT_REGEX}/
+    $stderr.put "Project names can only contain letter, numbers, and hyphens"
+    exit 1
+  end 
+end
+
+def validate_repository_name(name)
+  if name !~ /#{REPOSITORY_REGEX}/
+    $stderr.put "Repository names can only contain letter, numbers, and hyphens"
+    exit 1
+  end 
+end
+
+def validate_user_name(name)
+  if name !~ /#{USERNAME_REGEX}/
+    $stderr.put "User names can only contain letter, numbers, and hyphens"
+    exit 1
+  end 
+end
+
+def validate_action_name(name)
+  unless name == 'read' || name == 'write' || name == 'admin'
+    $stderr.put "Not a valid action (must be one of: read, write, admin)"
+    exit 1
+  end 
+end
+
+username = next_arg "Please specify the username to run as"
+command = next_arg "Please specify a command to run"
+
+if command == "run-as"
+  if username != "admin"
+    $stderr.puts "You don't have permission to do that"
+    exit 1
+  end
+  username = next_arg "Please specify the username to run as"
+  command = next_arg "Please specify a command to run"
+end
+
+@username = username
+
+def implies(a1, a2)
+  case a1
+  when 'admin'
+    true
+  when 'write'
+    a2 != 'admin'
+  when 'read'
+      a2 == 'read'
+  else
+    raise "Unknown action type: *#{a1}*"
+  end
+end
+
+def authorize(project_name, action)
+  unless is_authorized(project_name, action)
+    $stderr.puts "You don't have permission to do that"
+    exit 3
+  end
+end
+
+def is_authorized(project_name, action)
+  Dir.chdir(find_project_dir(project_name)) do
+    if action == 'read' && File.read('.visibility').strip == 'public'
+      return true
+    end
+    File.read(".permissions").split("\n").each do |line|
+      permission = line.strip.split('=')
+      line_username = permission[0]
+      line_action = permission[1]
+      if line_username == @username && implies(line_action, action)
+        return true
+      end
+    end
+    false
+  end
+end
+
+def find_account_dir(user_name)
+  File.join(HUB_DATA, "accounts", user_name)
+end
+
+def find_project_dir(project_name)
+  File.join(HUB_DATA, "projects", project_name)
+end
+
+def find_repository_dir(project_name, repository_dir)
+  File.join(find_project_dir(project_name), repository_dir)
+end
+
+def read_project_name
+  project_name = next_arg("Please specify a project name")
+  validate_project_name(project_name)
+  project_name
+end
+
+def read_repository_name
+  repository_name = next_arg("Please specify a repository name")
+  validate_repository_name(repository_name)
+  repository_name
+end
+
+def read_user_name
+  user_name = next_arg("Please specify a username")
+  validate_user_name(user_name)
+  user_name
+end
+
+def sync_keys
+  File.open(File.expand_path("~/.ssh/authorized_keys"), "w") do |file|
+    Dir.entries(File.join(HUB_DATA, "accounts")).each do |account|
+      next if account == '.' || account == '..'
+      key_dir = File.join(HUB_DATA, "accounts", account, "keys")
+      Dir.entries(key_dir).each do |name|
+        next if name == '.' || name == '..'
+        key = File.read(File.join(key_dir, name))
+        file << "command=\"hubbard #{@username}\" #{key} #{name}\n" 
+      end
+    end
+  end
+end
+
+command_file = File.expand_path(File.join(File.dirname(__FILE__), "..", "commands", "#{command}.rb"))
+
+if File.exist?(command_file)
+  load command_file
+else
+  $stderr.puts "Unknown command: #{command}"
+  exit 1
+end

data/commands/add-key.rb

@@ -0,0 +1,23 @@
+name = next_arg("Please specify the key name")
+if name !~ /[a-zA-Z0-9]+/
+  $stderr.puts "Not a valid key name (letters and numbers only)"
+  exit 1
+end
+
+key = $stdin.read.strip
+if key !~ /(ssh-rsa|ssh-dsa) ([a-zA-Z0-9\+\/]+[=]*)/
+  $stderr.puts "Not a valid key"
+  exit 1
+end
+
+type = $1
+value = $2
+
+dirname = File.join(find_account_dir(@username), "keys")
+FileUtils.mkdir_p(dirname)
+filename = File.join(dirname, name)
+File.open(filename, "w") do |file|
+  file << type << " " << value    
+end
+
+sync_keys

data/commands/add-permission.rb

@@ -0,0 +1,23 @@
+project_name = read_project_name
+authorize(project_name, 'admin')
+dir = find_project_dir(project_name)
+username = ARGV.shift
+action = ARGV.shift
+unless ['admin','write','read'].member?(action)
+  $stderr.puts "Not a valid action (must be one of: read, write, admin)"
+  exit 1
+end
+
+File.open(File.join(dir, ".lock"), "w+") do |lock|
+  lock.flock(File::LOCK_EX)
+  begin
+    filename = File.join(dir, ".permissions")
+    permissions = File.read(filename).split("\n").map { |line| line.strip }.select { |line| line.split('=')[0] != username }
+    permissions << "#{username}=#{action}"
+    File.open(filename, "w") do |file| 
+      permissions.each { |permission| file << permission << "\n" }
+    end
+  ensure
+    lock.flock(File::LOCK_UN)
+  end
+end

data/commands/create-project.rb

@@ -0,0 +1,14 @@
+require 'fileutils'
+
+project_name = read_project_name
+dir = find_project_dir(project_name)
+if File.exist?(dir)
+  $stderr.puts "Project already exists with that name"
+  exit 4
+end
+unless Dir.mkdir(dir)
+  $stderr.puts "Unable to create directory: #{dir}"
+end
+visibility = ARGV.member?("--private") ? "private" : "public"
+File.open(File.join(dir, ".permissions"), "w") { |f| f << "#{@username}=admin\n" }
+File.open(File.join(dir, ".visibility"), "w") { |f| f << "#{visibility}\n" }

data/commands/create-repository.rb

@@ -0,0 +1,8 @@
+project_name = read_project_name
+repository_name = read_repository_name
+authorize(project_name, 'admin')
+dir = find_repository_dir(project_name, repository_name)
+FileUtils.mkdir_p(dir)
+Dir.chdir(dir) do
+  exec "git init --bare" 
+end

data/commands/delete-project.rb

@@ -0,0 +1,4 @@
+project_name = read_project_name
+dir = find_project_dir(project_name)
+authorize(project_name, 'admin')
+FileUtils.rm_rf(dir)

data/commands/git-receive-pack.rb

@@ -0,0 +1,9 @@
+unless ARGV.shift =~ /(#{PROJECT_REGEX})\/(#{REPOSITORY_REGEX}).git/
+  $stderr.puts "Repository not found"
+  exit 1
+end
+project_name = $1
+repository_name = $2
+authorize(project_name, 'write')
+dir = find_repository_dir(project_name, repository_name)
+exec "git-receive-pack #{dir}"

data/commands/git-upload-pack.rb

@@ -0,0 +1,9 @@
+unless ARGV.shift =~ /(#{PROJECT_REGEX})\/(#{REPOSITORY_REGEX}).git/
+  $stderr.puts "Repository not found"
+  exit 1
+end
+project_name = $1
+repository_name = $2
+authorize(project_name, 'read')
+dir = find_repository_dir(project_name, repository_name)
+exec "git-upload-pack #{dir}"

data/commands/help.rb

@@ -0,0 +1,21 @@
+$stderr.puts <<-END
+Usage: hub <command>
+
+Projects:
+
+list-projects
+create-project <project>
+delete-project <project>
+
+Repositories:
+
+create-repository <project> <repository>
+delete-repository <project> <repository>
+
+Permissions:
+
+add-permission <project> <username> read|write|admin
+remove-permission <project> <username>
+
+END
+exit 0

data/commands/list-keys.rb

@@ -0,0 +1,5 @@
+dirname = File.join(find_account_dir(@username), "keys")
+Dir.entries(dirname).each do |name|
+  next if name == '.' || name == '..'
+  puts name
+end

data/commands/list-permissions.rb

@@ -0,0 +1,15 @@
+project_name = read_project_name
+authorize(project_name, 'admin')
+dir = find_project_dir(project_name)
+username = ARGV.shift
+action = ARGV.shift
+unless ['admin','write','read'].member?(action)
+  $stderr.puts "Not a valid action (must be one of: read, write, admin)"
+  exit 1
+end
+File.open(File.join(dir, ".permissions"), "r+") do |f| 
+  f.flock(File::LOCK_EX)
+  contents = f.read
+  puts contents
+  f.flock(File::LOCK_UN)
+end

data/commands/list-projects.rb

@@ -0,0 +1,6 @@
+Dir.foreach(File.join(HUB_DATA, 'projects')) do |dir|
+  next if dir == "." || dir == ".."
+  if is_authorized(dir, 'read')
+    puts dir
+  end
+end

data/commands/list-repositories.rb

@@ -0,0 +1,7 @@
+project_name = read_project_name
+authorize(project_name, 'read')
+Dir.foreach(find_project_dir(project_name)) do |repository_name|
+  next if repository_name =~ /^\./
+  git_url = "#{ENV['USER']}@#{ENV['HUB_HOST']}:#{project_name}/#{repository_name}.git"
+  puts "#{repository_name}\t#{git_url}"
+end

data/commands/remove-key.rb

@@ -0,0 +1,21 @@
+name = next_arg("Please specify the key name")
+if name !~ /[a-zA-Z0-9]+/
+  $stderr.puts "Not a valid key name (letters and numbers only)"
+  exit 1
+end
+
+dirname = File.join(find_account_dir(@username), "keys")
+FileUtils.mkdir_p(dirname)
+
+filename = File.join(dirname, name)
+if !File.exist?(filename)
+  $stderr.puts "Key not found"
+  exit 1
+end
+
+unless FileUtils.rm(filename)
+  $stderr.puts "Unable to delete key"
+  exit 1
+end
+
+sync_keys

data/commands/remove-permission.rb

@@ -0,0 +1,16 @@
+project_name = read_project_name
+authorize(project_name, 'admin')
+dir = find_project_dir(project_name)
+username = ARGV.shift
+File.open(File.join(dir, ".lock"), "w+") do |lock|
+  lock.flock(File::LOCK_EX)
+  begin
+    filename = File.join(dir, ".permissions")
+    permissions = File.read(filename).split("\n").map { |line| line.strip }.select { |line| line.split('=')[0] != username }
+    File.open(filename, "w") do |file| 
+      permissions.each { |permission| file << permission << "\n" }
+    end
+  ensure
+    lock.flock(File::LOCK_UN)
+  end
+end

data/spec/gitssh

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+HUB=File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'hubbard'))
+
+HUB_USERNAME=ENV['HUB_USERNAME']
+fail "Please define HUB_USERNAME" unless HUB_USERNAME
+
+# Ignore hostname passed in
+ARGV.shift
+
+$stderr.puts "#{HUB} #{HUB_USERNAME} #{ARGV.join(' ')}"
+exec "#{HUB} #{HUB_USERNAME} #{ARGV.join(' ')}"

data/spec/hubbard_spec.rb

@@ -0,0 +1,183 @@
+# Something in the Rakefile is generating 
+# a bunch of GIT_* environment variables,
+# which mess everything up, so undo.
+ENV.each do |key,value|
+  ENV[key] = nil if key =~ /^GIT_/
+end
+
+HUB=File.expand_path(File.join(File.dirname(__FILE__), "..", "bin", "hubbard"))
+
+require 'fileutils'
+
+ENV['HUB_USER'] = HUB_USER = "hub"
+ENV['HUB_HOST'] = HUB_HOST = "example.com"
+ENV['HUB_DATA'] = HUB_DATA =  File.expand_path(File.join(File.dirname(__FILE__), '..', "data"))
+ENV['GIT_SSH'] = File.expand_path(File.join(File.dirname(__FILE__), "gitssh"))
+
+def hub(username, command, input=nil)
+  if input
+    result = `echo #{input} | #{HUB} #{username} #{command}`
+  else
+    result = `#{HUB} #{username} #{command}`
+  end
+  if $?.exitstatus != 0
+    raise "Command failed: hub #{username} #{command}\n#{result}"
+  end
+  result
+end
+
+def git(username, command)
+  ENV['HUB_USERNAME'] = username
+  result = `git #{command}`
+  if $?.exitstatus != 0
+    raise "Command failed: git #{command}:\n#{result}"
+  end
+  result
+end
+
+describe "Hubble" do
+  before(:each) do
+    FileUtils.rm_rf HUB_DATA
+    FileUtils.rm_rf "tmp"
+  end
+
+  it "should create project" do
+    hub("kipper", "create-project foo")
+    projects = hub("kipper", "list-projects").split("\n")
+    projects.should == ["foo"]
+  end
+
+  it "should not allow multiple projects with same name" do
+    hub("kipper", "create-project foo")
+    lambda { hub("kipper", "create-project foo") }.should raise_error
+  end
+
+  it "should delete project" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "delete-project foo")
+
+    projects = hub("kipper", "list-projects").split("\n")
+    projects.should == []
+  end
+
+  it "should default to public project" do
+    hub("kipper", "create-project foo")
+
+    # Other users can see...
+    projects = hub("tiger", "list-projects").split("\n")
+    projects.should == ["foo"]
+
+    # But not delete
+    lambda { hub("tiger", "delete-project foo") }.should raise_error
+  end
+
+  it "should support private project" do
+    hub("kipper", "create-project foo --private")
+
+    # Other users can't see
+    projects = hub("tiger", "list-projects").split("\n")
+    projects.should == []
+  end
+
+  it "should create repositories" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "create-repository foo bar")
+
+    repositories = hub("kipper", "list-repositories foo").split("\n")
+    repositories.length.should == 1
+    name,url = repositories[0].split
+    name.should == "bar"
+    url.should == "#{ENV['USER']}@#{HUB_HOST}:foo/bar.git"    
+  end
+
+  def with_test_project
+    Dir.mkdir('tmp')
+    Dir.chdir('tmp') do
+      File.open("README", "w") { |f| f << "Hello, world\n" }
+      fail unless system "git init"
+      fail unless system "git add README"
+      fail unless system "git commit -m 'initial commit'" 
+      yield
+    end
+  end
+
+  it "should allow git push" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "create-repository foo bar")
+
+    with_test_project do
+      git("kipper", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+    end
+  end
+
+  it "should allow git push with write permissions" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "add-permission foo tiger write")
+    hub("kipper", "create-repository foo bar")
+
+    with_test_project do
+      git("tiger", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+    end
+  end
+
+  it "should not allow git push with read permissions" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "add-permission foo tiger read")
+    hub("kipper", "create-repository foo bar")
+
+    with_test_project do
+      lambda { git("tiger", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master") }.should raise_error
+    end
+  end
+
+  it "should allow git pull" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "create-repository foo bar")
+
+    with_test_project do
+      git("kipper", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+      git("kipper", "pull #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+    end
+  end
+
+  it "should not allow git pull with no permissions" do
+    hub("kipper", "create-project foo --private")
+    hub("kipper", "create-repository foo bar")
+
+    with_test_project do
+      git("kipper", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+      lambda { git("tiger", "pull #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master") }.should raise_error
+    end
+  end
+
+  it "should allow git pull with read permissions" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "create-repository foo bar")
+
+    with_test_project do
+      git("kipper", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+      git("tiger", "pull #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master")
+    end
+  end
+
+  it "should remove permission" do
+    hub("kipper", "create-project foo")
+    hub("kipper", "create-repository foo bar")
+    hub("kipper", "add-permission foo tiger read")
+    hub("kipper", "remove-permission foo tiger")
+
+    with_test_project do
+      lambda { git("tiger", "push #{ENV['USER']}@#{HUB_HOST}:foo/bar.git master") }.should raise_error
+    end
+  end
+
+  it "should add ssh key" do
+    hub("kipper", "add-key laptop", "ssh-rsa yabbadabba fdsa")
+  end
+
+  it "should allow admin to run-as another user" do
+    hub("admin", "run-as kipper create-project foo")
+    projects = hub("kipper", "list-projects").split("\n")
+    projects.should == ["foo"]
+  end
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'hubbard'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: hubbard
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Matthew Foemmel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-18 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: Hubbard is a command line tool for managing git repositories.
+email: git@foemmel.com
+executables: 
+- hubbard
+- hubbard~
+- hubbard
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bin/hubbard
+- commands/add-key.rb
+- commands/add-permission.rb
+- commands/create-project.rb
+- commands/create-repository.rb
+- commands/delete-project.rb
+- commands/git-receive-pack.rb
+- commands/git-upload-pack.rb
+- commands/help.rb
+- commands/list-keys.rb
+- commands/list-permissions.rb
+- commands/list-projects.rb
+- commands/list-repositories.rb
+- commands/remove-key.rb
+- commands/remove-permission.rb
+- lib/hubbard.rb
+- spec/gitssh
+- spec/hubbard_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mfoemmel/hubbard
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- ""
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Hubbard is a command line tool for managing git repositories.
+test_files: 
+- spec/hubbard_spec.rb
+- spec/spec_helper.rb