herokugarden 0.4.2

data/Rakefile

@@ -0,0 +1,101 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Print specdocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+	t.spec_opts = ["--format", "specdoc", "--dry-run"]
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Generate RCov code coverage report"
+Spec::Rake::SpecTask.new('rcov') do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.rcov = true
+	t.rcov_opts = ['--exclude', 'examples']
+end
+
+task :default => :spec
+
+######################################################
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+include FileUtils
+require 'lib/herokugarden'
+
+version = HerokuGarden::Client.version
+name = "herokugarden"
+
+spec = Gem::Specification.new do |s|
+	s.name = name
+	s.version = version
+	s.summary = "Client library and CLI to deploy Rails apps on Heroku Garden."
+	s.description = "Client library and command-line tool to manage and deploy Rails apps on Heroku Garden."
+	s.author = "Adam Wiggins"
+	s.email = "feedback@heroku.com"
+	s.homepage = "http://herokugarden.com/"
+	s.executables = [ "herokugarden" ]
+	s.default_executable = "herokugarden"
+	s.rubyforge_project = "herokugarden"
+	s.post_install_message = <<EOF
+
+---> Installing herokugarden v#{version}
+---> Migrate local checkouts using the git:transition command:
+
+     cd myapp/
+     herokugarden git:transition
+
+EOF
+
+	s.platform = Gem::Platform::RUBY
+	s.has_rdoc = true
+	
+	s.files = %w(Rakefile) +
+		Dir.glob("{bin,lib,spec}/**/*")
+	
+	s.require_path = "lib"
+	s.bindir = "bin"
+
+	s.add_dependency('rest-client', '>=0.5')
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :install => [ :test, :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{name}}
+end
+
+Rake::TestTask.new do |t|
+	t.libs << "spec"
+	t.test_files = FileList['spec/*_spec.rb']
+	t.verbose = true
+end
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'rdoc'
+	t.title    = "Heroku API"
+	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('README')
+	t.rdoc_files.include('REST')
+	t.rdoc_files.include('lib/heroku/*.rb')
+end
+
+CLEAN.include [ 'build/*', '**/*.o', '**/*.so', '**/*.a', 'lib/*-*', '**/*.log', 'pkg', 'lib/*.bundle', '*.gem', '.config' ]
+

data/bin/herokugarden

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'herokugarden'
+require 'herokugarden/command_line'
+
+usage = <<EOTXT
+=== Heroku Garden Commands
+  list - list your apps
+  create [<name>] - create a new app
+  info <app> - show app info, like web url and git repo
+  update <app> - update the app
+    --name <newname>
+    --public (true|false)
+    --mode (production|development)
+  sharing <app> - manage collaborators
+    --add <email>
+    --remove <email>
+    --access (edit|view)
+  rake <app> <command> - remotely execute a rake command
+  destroy <app> - destroy the app permanently
+  keys - manage your user's ssh public keys for git access
+    --add [<path to keyfile>]
+    --remove <keyname or all>
+
+Example story:
+  herokugarden create myapp
+  git clone git@herokugarden.com:myapp.git
+  cd myapp
+  (...make edits...)
+  git add .
+  git commit -m "changes"
+  git push
+  herokugarden update myapp --public true --mode production
+EOTXT
+
+command = ARGV.shift.strip.gsub(/:/, '_') rescue ""
+if command.length == 0
+	puts usage
+	exit 1
+end
+
+cli = HerokuGarden::CommandLine.new
+unless cli.methods.include? command
+	puts "no such method as #{command}, run without arguments for usage"
+	exit 2
+end
+
+cli.execute(command, ARGV)
+

data/lib/herokugarden.rb

@@ -0,0 +1,5 @@
+module HerokuGarden; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/herokugarden')
+
+require 'client'

data/lib/herokugarden/client.rb

@@ -0,0 +1,153 @@
+require 'rubygems'
+require 'rexml/document'
+require 'rest_client'
+require 'uri'
+
+# A Ruby class to call the Heroku REST API.  You might use this if you want to
+# manage your Heroku apps from within a Ruby program, such as Capistrano.
+# 
+# Example:
+# 
+#   require 'heroku'
+#   heroku = HerokuGarden::Client.new('me@example.com', 'mypass')
+#   heroku.create('myapp')
+#
+class HerokuGarden::Client
+	def self.version
+		'0.4.2'
+	end
+
+	attr_accessor :host, :user, :password
+
+	def initialize(user, password, host='herokugarden.com')
+		@user = user
+		@password = password
+		@host = host
+	end
+
+	# Show a list of apps which you are a collaborator on.
+	def list
+		doc = xml(get('/apps'))
+		doc.elements.to_a("//apps/app/name").map { |a| a.text }
+	end
+
+	# Show info such as mode, custom domain, and collaborators on an app.
+	def info(name, saferoute=false)
+		doc = xml(get("/#{'safe' if saferoute}apps/#{name}"))
+		attrs = { :collaborators => list_collaborators(name) }
+		doc.elements.to_a('//app/*').inject(attrs) do |hash, element|
+			hash[element.name.to_sym] = element.text; hash
+		end
+	end
+
+	# Create a new app, with an optional name.
+	def create(name=nil, options={})
+		params = {}
+		params['app[name]'] = name if name
+		xml(post('/apps', params)).elements["//app/name"].text
+	end
+
+	# Update an app.  Available attributes:
+	#   :name => rename the app (changes http and git urls)
+	#   :public => true | false
+	#   :mode => production | development
+	def update(name, attributes)
+		put("/apps/#{name}", :app => attributes)
+	end
+
+	# Destroy the app permanently.
+	def destroy(name)
+		delete("/apps/#{name}")
+	end
+
+	# Get a list of collaborators on the app, returns an array of hashes each of
+	# which contain :email and :access (=> edit | view) elements.
+	def list_collaborators(app_name)
+		doc = xml(get("/apps/#{app_name}/collaborators"))
+		doc.elements.to_a("//collaborators/collaborator").map do |a|
+			{ :email => a.elements['email'].text, :access => a.elements['access'].text }
+		end
+	end
+
+	# Invite a person by email address to collaborate on the app.  Optional
+	# third parameter can be edit or view.
+	def add_collaborator(app_name, email, access='view')
+		xml(post("/apps/#{app_name}/collaborators", { 'collaborator[email]' => email, 'collaborator[access]' => access }))
+	end
+
+	# Change an existing collaborator.
+	def update_collaborator(app_name, email, access)
+		put("/apps/#{app_name}/collaborators/#{escape(email)}", { 'collaborator[access]' => access })
+	end
+
+	# Remove a collaborator.
+	def remove_collaborator(app_name, email)
+		delete("/apps/#{app_name}/collaborators/#{escape(email)}")
+	end
+
+	# Get the list of ssh public keys for the current user.
+	def keys
+		doc = xml get('/user/keys')
+		doc.elements.to_a('//keys/key').map do |key|
+			key.elements['contents'].text
+		end
+	end
+
+	# Add an ssh public key to the current user.
+	def add_key(key)
+		post("/user/keys", key, { 'Content-Type' => 'text/ssh-authkey' })
+	end
+
+	# Remove an existing ssh public key from the current user.
+	def remove_key(key)
+		delete("/user/keys/#{escape(key)}")
+	end
+
+	# Clear all keys on the current user.
+	def remove_all_keys
+		delete("/user/keys")
+	end
+
+	# Run a rake command on the Heroku app.
+	def rake(app_name, cmd)
+		post("/apps/#{app_name}/rake", cmd)
+	end
+
+	##################
+
+	def resource(uri)
+		RestClient::Resource.new("http://#{host}", user, password)[uri]
+	end
+
+	def get(uri, extra_headers={})    # :nodoc:
+		resource(uri).get(heroku_headers.merge(extra_headers))
+	end
+
+	def post(uri, payload="", extra_headers={})    # :nodoc:
+		resource(uri).post(payload, heroku_headers.merge(extra_headers))
+	end
+
+	def put(uri, payload, extra_headers={})    # :nodoc:
+		resource(uri).put(payload, heroku_headers.merge(extra_headers))
+	end
+
+	def delete(uri)    # :nodoc:
+		resource(uri).delete
+	end
+
+	def heroku_headers   # :nodoc:
+		{
+			'X-Heroku-API-Version' => '2',
+			'User-Agent'           => "herokugarden-gem/#{self.class.version}",
+		}
+	end
+
+	def xml(raw)   # :nodoc:
+		REXML::Document.new(raw)
+	end
+
+	def escape(value)  # :nodoc:
+		escaped = URI.escape(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+		escaped.gsub('.', '%2E') # not covered by the previous URI.escape
+	end
+end

data/lib/herokugarden/command_line.rb

@@ -0,0 +1,450 @@
+require 'fileutils'
+
+# This wraps the Heroku::Client class with higher-level actions suitable for
+# use from the command line.
+class HerokuGarden::CommandLine
+	class CommandFailed < RuntimeError; end
+
+	def execute(command, args)
+		send(command, args)
+	rescue RestClient::Unauthorized
+		display "Authentication failure"
+	rescue RestClient::ResourceNotFound
+		display "Resource not found.  (Did you mistype the app name?)"
+	rescue RestClient::RequestFailed => e
+		display extract_error(e.response)
+	rescue HerokuGarden::CommandLine::CommandFailed => e
+		display e.message
+	end
+
+	def list(args)
+		list = heroku.list
+		if list.size > 0
+			display list.join("\n")
+		else
+			display "You have no apps."
+		end
+	end
+
+	def info(args)
+		name = args.shift.downcase.strip rescue ""
+		if name.length == 0 or name.slice(0, 1) == '-'
+			display "Usage: herokugarden info <app>"
+		else
+			attrs = heroku.info(name)
+			display "=== #{attrs[:name]}"
+			display "Web URL:        http://#{attrs[:name]}.#{heroku.host}/"
+			display "Domain name:    http://#{attrs[:domain_name]}/" if attrs[:domain_name]
+			display "Git Repo:       git@#{heroku.host}:#{attrs[:name]}.git"
+			display "Mode:           #{ attrs[:production] == 'true' ? 'production' : 'development' }"
+			display "Public:         #{ attrs[:'share-public'] == 'true' ? 'true' : 'false' }"
+
+			first = true
+			lead = "Collaborators:"
+			attrs[:collaborators].each do |collaborator|
+				display "#{first ? lead : ' ' * lead.length}  #{collaborator[:email]} (#{collaborator[:access]})"
+				first = false
+			end
+		end
+	end
+
+	def create(args)
+		name = args.shift.downcase.strip rescue nil
+		name = heroku.create(name, {})
+		display "Created http://#{name}.#{heroku.host}/ | git@#{heroku.host}:#{name}.git"
+	end
+
+	def update(args)
+		name = args.shift.downcase.strip rescue ""
+		raise CommandFailed, "Invalid app name" if name.length == 0 or name.slice(0, 1) == '-'
+
+		attributes = {}
+		extract_option(args, '--name') do |new_name|
+			attributes[:name] = new_name
+		end
+		extract_option(args, '--public', %w( true false )) do |public|
+			attributes[:share_public] = (public == 'true')
+		end
+		extract_option(args, '--mode', %w( production development )) do |mode|
+			attributes[:production] = (mode == 'production')
+		end
+		raise CommandFailed, "Nothing to update" if attributes.empty?
+		heroku.update(name, attributes)
+
+		app_name = attributes[:name] || name
+		display "http://#{app_name}.#{heroku.host}/ updated"
+	end
+
+	def clone(args)
+		name = args.shift.downcase.strip rescue ""
+		if name.length == 0 or name.slice(0, 1) == '-'
+			display "Usage: herokugarden clone <app>"
+			display "(this command is deprecated in favor of using the git repo url directly)"
+		else
+			cmd = "git clone #{git_repo_for(name)}"
+			display cmd
+			system cmd
+		end
+	end
+
+	def destroy(args)
+		name = args.shift.strip.downcase rescue ""
+		if name.length == 0 or name.slice(0, 1) == '-'
+			display "Usage: herokugarden destroy <app>"
+		else
+			heroku.destroy(name)
+			display "Destroyed #{name}"
+		end
+	end
+
+	def sharing(args)
+		name = args.shift.strip.downcase rescue ""
+		if name.length == 0 or name.slice(0, 1) == '-'
+			display "Usage: herokugarden sharing <app>"
+		else
+			access = extract_option(args, '--access', %w( edit view )) || 'view'
+			extract_option(args, '--add') do |email|
+				return add_collaborator(name, email, access)
+			end
+			extract_option(args, '--update') do |email|
+				return update_collaborator(name, email, access)
+			end
+			extract_option(args, '--remove') do |email|
+				return remove_collaborator(name, email)
+			end
+			return list_collaborators(name)
+		end
+	end
+
+	def collaborators(args)
+		sharing(args)
+	end
+
+	def add_collaborator(name, email, access)
+		display heroku.add_collaborator(name, email, access)
+	end
+
+	def update_collaborator(name, email, access)
+		heroku.update_collaborator(name, email, access)
+		display "Collaborator updated"
+	end
+
+	def remove_collaborator(name, email)
+		heroku.remove_collaborator(name, email)
+		display "Collaborator removed"
+	end
+
+	def list_collaborators(name)
+		list = heroku.list_collaborators(name)
+		display list.map { |c| "#{c[:email]} (#{c[:access]})" }.join("\n")
+	end
+	
+	def git_repo_for(name)
+		"git@#{heroku.host}:#{name}.git"
+	end
+
+	def rake(args)
+		app_name = args.shift.strip.downcase rescue ""
+		cmd = args.join(' ')
+		if app_name.length == 0 or cmd.length == 0
+			display "Usage: herokugarden rake <app> <command>"
+		else
+			puts heroku.rake(app_name, cmd)
+		end
+	end
+
+	def git_transition(args)
+		unless File.exists?(Dir.pwd + '/.git')
+			raise HerokuGarden::CommandLine::CommandFailed, "The current directory is not a git repository.\nBe sure to cd into the app's directory and try again."
+		end
+
+		gitconfig = File.read(Dir.pwd + '/.git/config')
+		if gitconfig.match(/url = git@herokugarden\.com:(.+)\.git/)
+			raise HerokuGarden::CommandLine::CommandFailed, "This git repo for #{app_name} is already up to date and pointing at herokugarden.com."
+		end
+		if app_name_match = gitconfig.match(/url = git@heroku\.com:(.+)\.git/)
+			app_name = app_name_match[1]
+			begin
+				attempt_git_transition(gitconfig, app_name, 'heroku.com')
+			rescue RestClient::ResourceNotFound
+				begin
+					attempt_git_transition(gitconfig, app_name, 'herokugarden.com')
+				rescue RestClient::ResourceNotFound
+					raise HerokuGarden::CommandLine::CommandFailed, "The current directory does not contain a known Heroku app."
+				end
+			end
+		else
+			raise HerokuGarden::CommandLine::CommandFailed, "The current directory does not contain a known Heroku app."
+		end
+	end
+
+	def attempt_git_transition(gitconfig, app_name, domain)
+		heroku.host = domain
+		if [nil, 'true'].include?(heroku.info(app_name, true)[:stack2])
+			raise HerokuGarden::CommandLine::CommandFailed, "#{app_name} is running on the Heroku production platform.\nThis git repo URL is valid and does not need to be changed."
+		else
+			File.open(Dir.pwd + '/.git/config', 'w') do |f|
+				f.write gitconfig.gsub("url = git@heroku.com:#{app_name}.git", "url = git@herokugarden.com:#{app_name}.git")
+			end
+			display "This git repo for #{app_name} has been updated to the new herokugarden.com URL."
+		end
+	end
+
+	############
+	attr_accessor :credentials
+
+	def heroku    # :nodoc:
+		@heroku ||= init_heroku
+	end
+
+	def init_heroku    # :nodoc:
+		HerokuGarden::Client.new(user, password, ENV['HEROKU_HOST'] || 'herokugarden.com')
+	end
+
+	def user    # :nodoc:
+		get_credentials
+		@credentials[0]
+	end
+
+	def password    # :nodoc:
+		get_credentials
+		@credentials[1]
+	end
+
+	def credentials_file
+		"#{home_directory}/.heroku/herokugarden_credentials"
+	end
+
+	def get_credentials    # :nodoc:
+		return if @credentials
+		unless @credentials = read_credentials
+			@credentials = ask_for_credentials
+			save_credentials
+		end
+		@credentials
+	end
+
+	def read_credentials
+		if File.exists? credentials_file
+			return File.read(credentials_file).split("\n")
+		end
+	end
+
+	def echo_off
+		system "stty -echo"
+	end
+
+	def echo_on
+		system "stty echo"
+	end
+
+	def ask_for_credentials
+		puts "Enter your Heroku credentials."
+
+		print "Email: "
+		user = gets.strip
+
+		print "Password: "
+		password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+		[ user, password ]
+	end
+
+	def ask_for_password_on_windows
+		require "Win32API"
+		char = nil
+		password = ''
+
+		while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+			break if char == 10 || char == 13 # received carriage return or newline
+			if char == 127 || char == 8 # backspace and delete
+				password.slice!(-1, 1)
+			else
+				password << char.chr
+			end
+		end
+		puts
+		return password
+	end
+
+	def ask_for_password
+		echo_off
+		password = gets.strip
+		puts
+		echo_on
+		return password
+	end
+
+	def save_credentials
+		begin
+			write_credentials
+			add_key
+		rescue RestClient::Unauthorized => e
+			delete_credentials
+			raise e unless retry_login?
+
+			display "\nAuthentication failed"
+			@credentials = ask_for_credentials
+			@heroku = init_heroku
+			retry
+		rescue Exception => e
+			delete_credentials
+			raise e
+		end
+	end
+
+	def retry_login?
+		@login_attempts ||= 0
+		@login_attempts += 1
+		@login_attempts < 3
+	end
+
+	def write_credentials
+		FileUtils.mkdir_p(File.dirname(credentials_file))
+		File.open(credentials_file, 'w') do |f|
+			f.puts self.credentials
+		end
+		set_credentials_permissions
+	end
+
+	def set_credentials_permissions
+		FileUtils.chmod 0700, File.dirname(credentials_file)
+		FileUtils.chmod 0600, credentials_file
+	end
+
+	def delete_credentials
+		FileUtils.rm_f(credentials_file)
+	end
+
+	def extract_option(args, options, valid_values=nil)
+		values = options.is_a?(Array) ? options : [options]
+		return unless opt_index = args.select { |a| values.include? a }.first
+		opt_value = args[args.index(opt_index) + 1] rescue nil
+
+		# remove option from args
+		args.delete(opt_index)
+		args.delete(opt_value)
+
+		if valid_values
+			opt_value = opt_value.downcase if opt_value
+			raise CommandFailed, "Invalid value '#{opt_value}' for option #{values.last}" unless valid_values.include?(opt_value)
+		end
+
+		block_given? ? yield(opt_value) : opt_value
+	end
+
+	def keys(*args)
+		args = args.first  # something weird with ruby argument passing
+
+		if args.empty?
+			list_keys
+			return
+		end
+
+		extract_option(args, '--add') do |keyfile|
+			add_key(keyfile)
+			return
+		end
+		extract_option(args, '--remove') do |arg|
+			remove_key(arg)
+			return
+		end
+
+		display "Usage: heroku keys [--add or --remove]"
+	end
+
+	def list_keys
+		keys = heroku.keys
+		if keys.empty?
+			display "No keys for #{user}"
+		else
+			display "=== #{keys.size} key#{keys.size > 1 ? 's' : ''} for #{user}"
+			keys.each do |key|
+				display key
+			end
+		end
+	end
+
+	def add_key(keyfile=nil)
+		keyfile ||= find_key
+		key = File.read(keyfile)
+
+		display "Uploading ssh public key #{keyfile}"
+		heroku.add_key(key)
+	end
+
+	def remove_key(arg)
+		if arg == 'all'
+			heroku.remove_all_keys
+			display "All keys removed."
+		else
+			heroku.remove_key(arg)
+			display "Key #{arg} removed."
+		end
+	end
+
+	def find_key
+		%w(rsa dsa).each do |key_type|
+			keyfile = "#{home_directory}/.ssh/id_#{key_type}.pub"
+			return keyfile if File.exists? keyfile
+		end
+		raise CommandFailed, "No ssh public key found in #{home_directory}/.ssh/id_[rd]sa.pub.  You may want to specify the full path to the keyfile."
+	end
+
+	# vvv Deprecated
+	def upload_authkey(*args)
+		extract_key!
+		display "Uploading ssh public key"
+		display "(upload_authkey is deprecated, please use \"heroku keys --add\" instead)"
+		heroku.add_key(authkey)
+	end
+
+	def extract_key!
+		return unless key_path = extract_option(ARGV, ['-k', '--key'])
+		raise "Please inform the full path for your ssh public key" if File.directory?(key_path)
+		raise "Could not read ssh public key in #{key_path}" unless @ssh_key = authkey_read(key_path)
+	end
+
+	def authkey_type(key_type)
+		authkey_read("#{home_directory}/.ssh/id_#{key_type}.pub")
+	end
+
+	def authkey_read(filename)
+		File.read(filename) if File.exists?(filename)
+	end
+
+	def authkey
+		return @ssh_key if @ssh_key
+		%w( rsa dsa ).each do |key_type|
+			key = authkey_type(key_type)
+			return key if key
+		end
+		raise "Your ssh public key was not found.  Make sure you have a rsa or dsa key in #{home_directory}/.ssh, or specify the full path to the keyfile."
+	end
+	# ^^^ Deprecated
+
+	def display(msg)
+		puts msg
+	end
+
+	def home_directory
+		running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+	end
+
+	def extract_error(response)
+		return "Not found" if response.code.to_i == 404
+
+		msg = parse_error_xml(response.body) rescue ''
+		msg = 'Internal server error' if msg.empty?
+		msg
+	end
+
+	def parse_error_xml(body)
+		xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+		xml_errors.map { |a| a.text }.join(" / ")
+	end
+
+	def running_on_windows?
+		RUBY_PLATFORM =~ /mswin32/
+	end
+end

data/spec/base.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'spec'
+require 'fileutils'
+
+require File.dirname(__FILE__) + '/../lib/herokugarden'
+require 'command_line'
+
+class Module
+	def redefine_const(name, value)
+		__send__(:remove_const, name) if const_defined?(name)
+		const_set(name, value)
+	end
+end

data/spec/client_spec.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/base'
+
+describe HerokuGarden::Client do
+	before do
+		@client = HerokuGarden::Client.new(nil, nil)
+		@resource = mock('heroku rest resource')
+	end
+
+	it "list -> get a list of this user's apps" do
+		@client.should_receive(:resource).with('/apps').and_return(@resource)
+		@resource.should_receive(:get).and_return <<EOXML
+<?xml version="1.0" encoding="UTF-8"?>
+<apps type="array">
+	<app><name>myapp1</name></app>
+	<app><name>myapp2</name></app>
+</apps>
+EOXML
+		@client.list.should == %w(myapp1 myapp2)
+	end
+
+	it "info -> get app attributes" do
+		@client.should_receive(:resource).with('/apps/myapp').and_return(@resource)
+		@resource.should_receive(:get).and_return <<EOXML
+<?xml version='1.0' encoding='UTF-8'?>
+<app>
+	<blessed type='boolean'>true</blessed>
+	<created-at type='datetime'>2008-07-08T17:21:50-07:00</created-at>
+	<id type='integer'>49134</id>
+	<name>testgems</name>
+	<production type='boolean'>true</production>
+	<share-public type='boolean'>true</share-public>
+	<domain_name/>
+</app>
+EOXML
+		@client.stub!(:list_collaborators).and_return([:jon, :mike])
+		@client.info('myapp').should == { :blessed => 'true', :'created-at' => '2008-07-08T17:21:50-07:00', :id => '49134', :name => 'testgems', :production => 'true', :'share-public' => 'true', :domain_name => nil, :collaborators => [:jon, :mike] }
+	end
+
+	it "create -> create a new blank app" do
+		@client.should_receive(:resource).with('/apps').and_return(@resource)
+		@resource.should_receive(:post).and_return <<EOXML
+<?xml version="1.0" encoding="UTF-8"?>
+<app><name>untitled-123</name></app>
+EOXML
+		@client.create.should == "untitled-123"
+	end
+
+	it "create(name) -> create a new blank app with a specified name" do
+		@client.should_receive(:resource).with('/apps').and_return(@resource)
+		@resource.should_receive(:post).with({ 'app[name]' => 'newapp' }, @client.heroku_headers).and_return <<EOXML
+<?xml version="1.0" encoding="UTF-8"?>
+<app><name>newapp</name></app>
+EOXML
+		@client.create("newapp").should == "newapp"
+	end
+
+	it "update(name, attributes) -> updates existing apps" do
+		@client.should_receive(:resource).with('/apps/myapp').and_return(@resource)
+		@resource.should_receive(:put).with({ :app => { :mode => 'production', :public => true } }, anything)
+		@client.update("myapp", :mode => 'production', :public => true)
+	end
+
+	it "destroy(name) -> destroy the named app" do
+		@client.should_receive(:resource).with('/apps/destroyme').and_return(@resource)
+		@resource.should_receive(:delete)
+		@client.destroy("destroyme")
+	end
+
+	it "rake(app_name, cmd) -> run a rake command on the app" do
+		@client.should_receive(:resource).with('/apps/myapp/rake').and_return(@resource)
+		@resource.should_receive(:post).with('db:migrate', @client.heroku_headers)
+		@client.rake('myapp', 'db:migrate')
+	end
+
+	describe "collaborators" do
+		it "list(app_name) -> list app collaborators" do
+			@client.should_receive(:resource).with('/apps/myapp/collaborators').and_return(@resource)
+			@resource.should_receive(:get).and_return <<EOXML
+<?xml version="1.0" encoding="UTF-8"?>
+<collaborators type="array">
+	<collaborator><email>joe@example.com</email><access>edit</access></collaborator>
+	<collaborator><email>jon@example.com</email><access>view</access></collaborator>
+</collaborators>
+EOXML
+			@client.list_collaborators('myapp').should == [
+				{ :email => 'joe@example.com', :access => 'edit' }, 
+				{ :email => 'jon@example.com', :access => 'view' }
+			]
+		end
+
+		it "add_collaborator(app_name, email, access) -> adds collaborator to app" do
+			@client.should_receive(:resource).with('/apps/myapp/collaborators').and_return(@resource)
+			@resource.should_receive(:post).with({ 'collaborator[email]' => 'joe@example.com', 'collaborator[access]' => 'edit'}, anything)
+			@client.add_collaborator('myapp', 'joe@example.com', 'edit')
+		end
+
+		it "update_collaborator(app_name, email, access) -> updates existing collaborator record" do
+			@client.should_receive(:resource).with('/apps/myapp/collaborators/joe%40example%2Ecom').and_return(@resource)
+			@resource.should_receive(:put).with({ 'collaborator[access]' => 'view'}, anything)
+			@client.update_collaborator('myapp', 'joe@example.com', 'view')
+		end
+
+		it "remove_collaborator(app_name, email, access) -> removes collaborator from app" do
+			@client.should_receive(:resource).with('/apps/myapp/collaborators/joe%40example%2Ecom').and_return(@resource)
+			@resource.should_receive(:delete)
+			@client.remove_collaborator('myapp', 'joe@example.com')
+		end
+	end
+
+	describe "ssh keys" do
+		it "fetches a list of the user's current keys" do
+			@client.should_receive(:resource).with('/user/keys').and_return(@resource)
+			@resource.should_receive(:get).and_return <<EOXML
+<?xml version="1.0" encoding="UTF-8"?>
+<keys type="array">
+  <key>
+    <contents>ssh-dss thekey== joe@workstation</contents>
+  </key>
+</keys>
+EOXML
+			@client.keys.should == [ "ssh-dss thekey== joe@workstation" ]
+		end
+
+		it "add_key(key) -> add an ssh key (e.g., the contents of id_rsa.pub) to the user" do
+			@client.should_receive(:resource).with('/user/keys').and_return(@resource)
+			@client.stub!(:heroku_headers).and_return({})
+			@resource.should_receive(:post).with('a key', 'Content-Type' => 'text/ssh-authkey')
+			@client.add_key('a key')
+		end
+
+		it "remove_key(key) -> remove an ssh key by name (user@box)" do
+			@client.should_receive(:resource).with('/user/keys/joe%40workstation').and_return(@resource)
+			@resource.should_receive(:delete)
+			@client.remove_key('joe@workstation')
+		end
+
+		it "remove_all_keys -> removes all ssh keys for the user" do
+			@client.should_receive(:resource).with('/user/keys').and_return(@resource)
+			@resource.should_receive(:delete)
+			@client.remove_all_keys
+		end
+	end
+
+	describe "internal" do
+		it "creates a RestClient resource for making calls" do
+			@client.stub!(:host).and_return('heroku.com')
+			@client.stub!(:user).and_return('joe@example.com')
+			@client.stub!(:password).and_return('secret')
+
+			res = @client.resource('/xyz')
+
+			res.url.should == 'http://heroku.com/xyz'
+			res.user.should == 'joe@example.com'
+			res.password.should == 'secret'
+		end
+	end
+end

data/spec/command_line_spec.rb

@@ -0,0 +1,334 @@
+require File.dirname(__FILE__) + '/base'
+
+describe HerokuGarden::CommandLine do
+	before do
+		@cli = HerokuGarden::CommandLine.new
+		@cli.stub!(:display)
+		@cli.stub!(:print)
+		@cli.stub!(:ask_for_credentials).and_raise("ask_for_credentials should not be called by specs")
+	end
+
+	describe "credentials" do
+		it "reads credentials from the credentials file" do
+			sandbox = "/tmp/cli_spec_#{Process.pid}"
+			File.open(sandbox, "w") { |f| f.write "user\npass\n" }
+			@cli.stub!(:credentials_file).and_return(sandbox)
+			@cli.read_credentials.should == %w(user pass)
+		end
+
+		it "takes the user from the first line and the password from the second line" do
+			@cli.stub!(:read_credentials).and_return(%w(user pass))
+			@cli.user.should == 'user'
+			@cli.password.should == 'pass'
+		end
+
+		it "asks for credentials when the file doesn't exist" do
+			sandbox = "/tmp/cli_spec_#{Process.pid}"
+			FileUtils.rm_rf(sandbox)
+			@cli.stub!(:credentials_file).and_return(sandbox)
+			@cli.should_receive(:ask_for_credentials).and_return([ 'u', 'p'])
+			@cli.should_receive(:save_credentials)
+			@cli.get_credentials.should == [ 'u', 'p' ]
+		end
+
+		it "writes the credentials to a file" do
+			sandbox = "/tmp/cli_spec_#{Process.pid}"
+			FileUtils.rm_rf(sandbox)
+			@cli.stub!(:credentials_file).and_return(sandbox)
+			@cli.stub!(:credentials).and_return(['one', 'two'])
+			@cli.should_receive(:set_credentials_permissions)
+			@cli.write_credentials
+			File.read(sandbox).should == "one\ntwo\n"
+		end
+
+		it "sets ~/.heroku/credentials to be readable only by the user" do
+			sandbox = "/tmp/cli_spec_#{Process.pid}"
+			FileUtils.rm_rf(sandbox)
+			FileUtils.mkdir_p(sandbox)
+			fname = "#{sandbox}/file"
+			system "touch #{fname}"
+			@cli.stub!(:credentials_file).and_return(fname)
+			@cli.set_credentials_permissions
+			File.stat(sandbox).mode.should == 040700
+			File.stat(fname).mode.should == 0100600
+		end
+
+		it "writes credentials and uploads authkey when credentials are saved" do
+			@cli.stub!(:credentials)
+			@cli.should_receive(:write_credentials)
+			@cli.should_receive(:add_key)
+			@cli.save_credentials
+		end
+
+		it "save_credentials deletes the credentials when the upload authkey is unauthorized" do
+			@cli.stub!(:write_credentials)
+			@cli.stub!(:retry_login?).and_return(false)
+			@cli.should_receive(:add_key).and_raise(RestClient::Unauthorized)
+			@cli.should_receive(:delete_credentials)
+			lambda { @cli.save_credentials }.should raise_error(RestClient::Unauthorized)
+		end
+
+		it "save_credentials deletes the credentials when there's no authkey" do
+			@cli.stub!(:write_credentials)
+			@cli.should_receive(:add_key).and_raise(RuntimeError)
+			@cli.should_receive(:delete_credentials)
+			lambda { @cli.save_credentials }.should raise_error
+		end
+
+		it "save_credentials deletes the credentials when the authkey is weak" do
+			@cli.stub!(:write_credentials)
+			@cli.should_receive(:add_key).and_raise(RestClient::RequestFailed)
+			@cli.should_receive(:delete_credentials)
+			lambda { @cli.save_credentials }.should raise_error
+		end
+
+		it "asks for login again when not authorized, for three times" do
+			@cli.stub!(:write_credentials)
+			@cli.stub!(:delete_credentials)
+			@cli.stub!(:add_key).and_raise(RestClient::Unauthorized)
+			@cli.should_receive(:ask_for_credentials).exactly(4).times
+			lambda { @cli.save_credentials }.should raise_error(RestClient::Unauthorized)
+		end
+
+		it "deletes the credentials file" do
+			FileUtils.should_receive(:rm_f).with(@cli.credentials_file)
+			@cli.delete_credentials
+		end
+	end
+
+	describe "key management" do
+		before do
+			@cli.instance_variable_set('@credentials', %w(user pass))
+		end
+
+		it "finds the user's ssh key in ~/ssh/id_rsa.pub" do
+			@cli.stub!(:home_directory).and_return('/home/joe')
+			File.should_receive(:exists?).with('/home/joe/.ssh/id_rsa.pub').and_return(true)
+			@cli.find_key.should == '/home/joe/.ssh/id_rsa.pub'
+		end
+
+		it "finds the user's ssh key in ~/ssh/id_dsa.pub" do
+			@cli.stub!(:home_directory).and_return('/home/joe')
+			File.should_receive(:exists?).with('/home/joe/.ssh/id_rsa.pub').and_return(false)
+			File.should_receive(:exists?).with('/home/joe/.ssh/id_dsa.pub').and_return(true)
+			@cli.find_key.should == '/home/joe/.ssh/id_dsa.pub'
+		end
+
+		it "raises an exception if neither id_rsa or id_dsa were found" do
+			@cli.stub!(:home_directory).and_return('/home/joe')
+			File.stub!(:exists?).and_return(false)
+			lambda { @cli.find_key }.should raise_error(HerokuGarden::CommandLine::CommandFailed)
+		end
+
+		it "adds a key from the default locations if no key filename is supplied" do
+			@cli.should_receive(:find_key).and_return('/home/joe/.ssh/id_rsa.pub')
+			File.should_receive(:read).with('/home/joe/.ssh/id_rsa.pub').and_return('ssh-rsa xyz')
+			@cli.heroku.should_receive(:add_key).with('ssh-rsa xyz')
+			@cli.add_key
+		end
+
+		it "adds a key from a specified keyfile path" do
+			@cli.should_not_receive(:find_key)
+			File.should_receive(:read).with('/my/key.pub').and_return('ssh-rsa xyz')
+			@cli.heroku.should_receive(:add_key).with('ssh-rsa xyz')
+			@cli.add_key('/my/key.pub')
+		end
+	end
+
+	describe "deprecated key management" do
+		it "gets pub keys from the user's home directory" do
+			@cli.should_receive(:home_directory).and_return('/Users/joe')
+			File.should_receive(:exists?).with('/Users/joe/.ssh/id_xyz.pub').and_return(true)
+			File.should_receive(:read).with('/Users/joe/.ssh/id_xyz.pub').and_return('ssh-xyz somehexkey')
+			@cli.authkey_type('xyz').should == 'ssh-xyz somehexkey'
+		end
+
+		it "gets the rsa key" do
+			@cli.stub!(:authkey_type).with('rsa').and_return('ssh-rsa somehexkey')
+			@cli.authkey.should == 'ssh-rsa somehexkey'
+		end
+
+		it "gets the dsa key when there's no rsa" do
+			@cli.stub!(:authkey_type).with('rsa').and_return(nil)
+			@cli.stub!(:authkey_type).with('dsa').and_return('ssh-dsa somehexkey')
+			@cli.authkey.should == 'ssh-dsa somehexkey'
+		end
+
+		it "raises a friendly error message when no key is found" do
+			@cli.stub!(:authkey_type).with('rsa').and_return(nil)
+			@cli.stub!(:authkey_type).with('dsa').and_return(nil)
+			lambda { @cli.authkey }.should raise_error
+		end
+
+		it "accepts a custom key via the -k parameter" do
+			Object.redefine_const(:ARGV, ['-k', '/Users/joe/sshkeys/mykey.pub'])
+			@cli.should_receive(:authkey_read).with('/Users/joe/sshkeys/mykey.pub').and_return('ssh-rsa somehexkey')
+			@cli.extract_key!
+			@cli.authkey.should == 'ssh-rsa somehexkey'
+		end
+
+		it "extracts options from ARGV" do
+			Object.redefine_const(:ARGV, %w( a b --something value c d ))
+			@cli.extract_option(ARGV, '--something').should == 'value'
+			ARGV.should == %w( a b c d )
+		end
+
+		it "rejects options outside valid values for ARGV" do
+			Object.redefine_const(:ARGV, %w( -boolean_option t ))
+			lambda { @cli.extract_argv_option('-boolean_option', %w( true false )) }.should raise_error
+		end
+
+		it "uploads the ssh authkey (deprecated in favor of add_key)" do
+			@cli.should_receive(:extract_key!)
+			@cli.should_receive(:authkey).and_return('my key')
+			heroku = mock("heroku client")
+			@cli.should_receive(:init_heroku).and_return(heroku)
+			heroku.should_receive(:add_key).with('my key')
+			@cli.upload_authkey
+		end
+
+		it "gets the home directory from HOME when running on *nix" do
+			ENV.should_receive(:[]).with('HOME').and_return(@home)
+			@cli.stub!(:running_on_windows?).and_return(false)
+			@cli.home_directory.should == @home
+		end
+
+		it "gets the home directory from USERPROFILE when running on windows" do
+			ENV.should_receive(:[]).with('USERPROFILE').and_return(@home)
+			@cli.stub!(:running_on_windows?).and_return(true)
+			@cli.home_directory.should == @home
+		end
+
+		it "detects it's running on windows" do
+			Object.redefine_const(:RUBY_PLATFORM, 'i386-mswin32')
+			@cli.should be_running_on_windows
+		end
+
+		it "doesn't consider cygwin as windows" do
+			Object.redefine_const(:RUBY_PLATFORM, 'i386-cygwin')
+			@cli.should_not be_running_on_windows
+		end
+	end
+
+	describe "execute" do
+		it "executes an action" do
+			@cli.should_receive(:my_action).with(%w(arg1 arg2))
+			@cli.execute('my_action', %w(arg1 arg2))
+		end
+
+		it "catches unauthorized errors" do
+			@cli.should_receive(:my_action).and_raise(RestClient::Unauthorized)
+			@cli.should_receive(:display).with('Authentication failure')
+			@cli.execute('my_action', 'args')
+		end
+
+		it "parses rails-format error xml" do
+			@cli.parse_error_xml('<errors><error>Error 1</error><error>Error 2</error></errors>').should == 'Error 1 / Error 2'
+		end
+
+		it "does not catch general exceptions, those are shown to the user as normal" do
+			@cli.should_receive(:my_action).and_raise(RuntimeError)
+			lambda { @cli.execute('my_action', 'args') }.should raise_error(RuntimeError)
+		end
+	end
+
+	describe "app actions" do
+		before do
+			@cli.instance_variable_set('@credentials', %w(user pass))
+		end
+
+		it "shows app info" do
+			@cli.heroku.should_receive(:info).with('myapp').and_return({ :name => 'myapp', :collaborators => [] })
+			@cli.heroku.stub!(:domain).and_return('heroku.com')
+			@cli.should_receive(:display).with('=== myapp')
+			@cli.should_receive(:display).with('Web URL:        http://myapp.herokugarden.com/')
+			@cli.info([ 'myapp' ])
+		end
+
+		it "creates without a name" do
+			@cli.heroku.should_receive(:create).with(nil, {}).and_return("untitled-123")
+			@cli.create([])
+		end
+
+		it "creates with a name" do
+			@cli.heroku.should_receive(:create).with('myapp', {}).and_return("myapp")
+			@cli.create([ 'myapp' ])
+		end
+
+		it "updates app" do
+			@cli.heroku.should_receive(:update).with('myapp', { :name => 'myapp2', :share_public => true, :production => true })
+			@cli.update([ 'myapp', '--name', 'myapp2', '--public', 'true', '--mode', 'production' ])
+		end
+
+		it "clones the app (deprecated in favor of straight git clone)" do
+			@cli.should_receive(:system).with('git clone git@herokugarden.com:myapp.git')
+			@cli.clone([ 'myapp' ])
+		end
+	end
+
+	describe "collaborators" do
+		before do
+			@cli.instance_variable_set('@credentials', %w(user pass))
+		end
+
+		it "list collaborators when there's just the app name" do
+			@cli.heroku.should_receive(:list_collaborators).and_return([])
+			@cli.collaborators(['myapp'])
+		end
+
+		it "add collaborators with default access to view only" do
+			@cli.heroku.should_receive(:add_collaborator).with('myapp', 'joe@example.com', 'view')
+			@cli.collaborators(['myapp', '--add', 'joe@example.com'])
+		end
+
+		it "add collaborators with edit access" do
+			@cli.heroku.should_receive(:add_collaborator).with('myapp', 'joe@example.com', 'edit')
+			@cli.collaborators(['myapp', '--add', 'joe@example.com', '--access', 'edit'])
+		end
+
+		it "updates collaborators" do
+			@cli.heroku.should_receive(:update_collaborator).with('myapp', 'joe@example.com', 'view')
+			@cli.collaborators(['myapp', '--update', 'joe@example.com', '--access', 'view'])
+		end
+
+		it "removes collaborators" do
+			@cli.heroku.should_receive(:remove_collaborator).with('myapp', 'joe@example.com')
+			@cli.collaborators(['myapp', '--remove', 'joe@example.com'])
+		end
+	end
+
+	describe "git transition" do
+		before do
+			@cli.instance_variable_set('@credentials', %w(user pass))
+			Dir.stub!(:pwd).and_return('/apps/myapp')
+		end
+
+		it "requires a git repo" do
+			File.stub!(:exists?).with('/apps/myapp/.git').and_return(false)
+			lambda { @cli.git_transition([]) }.should raise_error(HerokuGarden::CommandLine::CommandFailed)
+		end
+
+		it "requires a remote entry with git@heroku.com:appname.git" do
+			File.stub!(:exists?).with('/apps/myapp/.git').and_return(true)
+			File.stub!(:read).with('/apps/myapp/.git/config').and_return('config without app')
+			lambda { @cli.git_transition([]) }.should raise_error(HerokuGarden::CommandLine::CommandFailed)
+		end
+
+		it "doesn't update stack2 apps" do
+			File.stub!(:exists?).with('/apps/myapp/.git').and_return(true)
+			File.stub!(:read).with('/apps/myapp/.git/config').and_return("[remote \"heroku\"]\n\turl = git@heroku.com:myapp.git")
+			@cli.heroku.should_receive(:info).with('myapp', true).and_return({ :stack2 => 'true' })
+			lambda { @cli.git_transition([]) }.should raise_error(HerokuGarden::CommandLine::CommandFailed)
+		end
+
+		it "updates the gitconfig" do
+			File.stub!(:exists?).with('/apps/myapp/.git').and_return(true)
+			File.stub!(:read).with('/apps/myapp/.git/config').and_return("[remote \"heroku\"]\n\turl = git@heroku.com:myapp.git")
+			@cli.heroku.should_receive(:info).with('myapp', true).and_return({ :stack2 => 'false' })
+			gitconfig = mock('git config')
+			File.should_receive(:open).with('/apps/myapp/.git/config', 'w').and_yield(gitconfig)
+			gitconfig.should_receive(:write).with("[remote \"heroku\"]\n\turl = git@herokugarden.com:myapp.git")
+			@cli.git_transition([])
+		end
+	end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: herokugarden
+version: !ruby/object:Gem::Version 
+  version: 0.4.2
+platform: ruby
+authors: 
+- Adam Wiggins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-14 00:00:00 -08:00
+default_executable: herokugarden
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.5"
+    version: 
+description: Client library and command-line tool to manage and deploy Rails apps on Heroku Garden.
+email: feedback@heroku.com
+executables: 
+- herokugarden
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- bin/herokugarden
+- lib/herokugarden
+- lib/herokugarden/client.rb
+- lib/herokugarden/command_line.rb
+- lib/herokugarden.rb
+- spec/base.rb
+- spec/client_spec.rb
+- spec/command_line_spec.rb
+has_rdoc: true
+homepage: http://herokugarden.com/
+post_install_message: |+
+  
+  ---> Installing herokugarden v0.4.2
+  ---> Migrate local checkouts using the git:transition command:
+  
+       cd myapp/
+       herokugarden git:transition
+  
+rdoc_options: []
+
+require_paths: 
+- lib
+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: herokugarden
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Client library and CLI to deploy Rails apps on Heroku Garden.
+test_files: []
+