github-auth 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 103b97306c0adbb26e02a782f02c8244557fb665
+  data.tar.gz: b95cbdc7fb511a1346bbf7bb222034c8a1103f60
+SHA512:
+  metadata.gz: 4ad87cd1b81d17f581e209cfc4f190a5135f7e8b141fd421968e51ff221d8bf25083701efde8cf45b1affc6e1343e13cefc23c2be4099fc62aed2125bdeb0227
+  data.tar.gz: 03ec6d0356ecb5ba1c12f56e7edbd5ab284bfa151aab0d1453d001bc9acac248bce461b70749f17072e18ea87a428c9be9a824d0cc2ecb39bda9c5eacc406ba3

data/.gitignore

@@ -0,0 +1,18 @@
+*.swp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in github-auth.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Chris Hunt
+
+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,119 @@
+# gh-auth
+[![Travis CI](https://travis-ci.org/chrishunt/github-auth.png)](https://travis-ci.org/chrishunt/github-auth)
+[![Coverage Status](https://coveralls.io/repos/chrishunt/github-auth/badge.png?branch=master)](https://coveralls.io/r/chrishunt/github-auth)
+[![Code Climate](https://codeclimate.com/github/chrishunt/github-auth.png)](https://codeclimate.com/github/chrishunt/github-auth)
+
+## Description
+
+If you decide to [`#pairwithme`](https://twitter.com/search?q=%23pairwithme),
+we'll probably be SSHing into my laptop, your laptop, or some laptop in the
+sky. Since I'd rather not send you a password over email or Skype, we'll use
+public key authentication.
+
+`gh-auth` allows you to easily add and remove any Github user's public ssh keys
+from your [`authorized_keys`](http://en.wikipedia.org/wiki/Ssh-agent) file.
+
+Let's say you'd like to pair with me, just run:
+
+```bash
+$ gh-auth add chrishunt
+Adding 2 key(s) to '/Users/chris/.ssh/authorized_keys'
+```
+
+Now I can ssh into your machine! That was easy. When we're done working, you
+can revoke my access with:
+
+```bash
+$ gh-auth remove chrishunt
+Removing 2 key(s) from '/Users/chris/.ssh/authorized_keys'
+```
+
+You can add and remove any number of users at the same time.
+
+```bash
+$ gh-auth add chrishunt zachmargolis
+Adding 4 key(s) to '/Users/chris/.ssh/authorized_keys'
+
+$ gh-auth remove chrishunt
+Removing 2 key(s) from '/Users/chris/.ssh/authorized_keys'
+
+$ gh-auth remove zachmargolis
+Removing 2 key(s) from '/Users/chris/.ssh/authorized_keys'
+```
+
+## Usage
+
+```bash
+usage: gh-auth [add|remove] <username>
+```
+
+## Installation
+
+Install the `github-auth` gem:
+
+```bash
+$ gem install github-auth
+```
+
+### SSH Public Key Authentication (Mac OS X)
+
+Public key authentication works with Mac OS by default, but you'll need to get
+your ssh server running. This is done by ticking 'Remote Login' in the
+'Sharing' panel of System Preferences.
+
+![]('https://raw.github.com/chrishunt/github-auth/master/img/mac-os-ssh-sharing.png')
+
+Now that SSH is running, make sure you have the correct permissions set for
+your authorized keys.
+
+```bash
+$ chmod 700 ~/.ssh
+$ chmod 600 ~/.ssh/authorized_keys
+```
+
+### Verification
+
+If you'd like to verify that everything is working as expected, you can test
+right from your machine.
+
+First, authorized yourself for ssh. (Make sure to replace 'chrishunt' with
+*your* Github username)
+
+```bash
+$ gh-auth add chrishunt
+Adding 2 key(s) to '/Users/chris/.ssh/authorized_keys'
+```
+
+Next, open an SSH session to your machine with public key authentication. It
+should work just fine.
+
+```bash
+$ ssh -o PreferredAuthentications=publickey localhost
+
+(localhost)$
+```
+
+Now remove your public keys from the keys file:
+
+```bash
+$ gh-auth remove chrishunt
+Removing 2 key(s) from '/Users/chris/.ssh/authorized_keys'
+```
+
+You should no longer be able to login to the machine since the keys have been
+removed.
+
+```bash
+$ ssh -o PreferredAuthentications=publickey localhost
+
+> Permission denied (publickey,keyboard-interactive)
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Run the tests (`bundle exec rake spec`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Run all tests'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--color --order random'
+end
+
+task default: :spec

data/bin/gh-auth

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'github/auth'
+
+Github::Auth::CLI.new(ARGV).execute

data/github-auth.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'github/auth/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'github-auth'
+  spec.version       = Github::Auth::VERSION
+  spec.authors       = ['Chris Hunt']
+  spec.email         = ['c@chrishunt.co']
+  spec.description   = %q{SSH key management for Github users}
+  spec.summary       = %q{SSH key management for Github users}
+  spec.homepage      = 'https://github.com/chrishunt/github-auth'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'sinatra'
+  spec.add_development_dependency 'thin'
+
+  spec.add_runtime_dependency 'httparty'
+end

data/lib/github/auth.rb

@@ -0,0 +1,4 @@
+require 'github/auth/version'
+require 'github/auth/keys_client'
+require 'github/auth/keys_file'
+require 'github/auth/cli'

data/lib/github/auth/cli.rb

@@ -0,0 +1,100 @@
+module Github::Auth
+  class CLI
+    attr_reader :command, :usernames
+
+    COMMANDS = %w(add remove)
+
+    def initialize(argv)
+      @command   = argv.shift
+      @usernames = argv
+    end
+
+    def execute
+      if COMMANDS.include?(command) && !usernames.empty?
+        send command
+      else
+        print_usage
+      end
+    end
+
+    private
+
+    def add
+      on_keys_file :write!,
+        "Adding #{keys.count} key(s) to '#{keys_file.path}'"
+    end
+
+    def remove
+      on_keys_file :delete!,
+        "Removing #{keys.count} key(s) from '#{keys_file.path}'"
+    end
+
+    def on_keys_file(action, message)
+      puts message
+      rescue_keys_file_errors { keys_file.send action, keys }
+    end
+
+    def rescue_keys_file_errors
+      yield
+    rescue KeysFile::PermissionDeniedError
+      print_permission_denied
+    rescue KeysFile::FileDoesNotExistError
+      print_file_does_not_exist
+    end
+
+    def print_usage
+      puts "usage: gh-auth [#{COMMANDS.join '|'}] <username>"
+    end
+
+    def print_permission_denied
+      puts 'Permission denied!'
+      puts
+      puts "Make sure you have write permissions for '#{keys_file.path}'"
+    end
+
+    def print_file_does_not_exist
+      puts "Keys file does not exist!"
+      puts
+      puts "Create one now and try again:"
+      puts
+      puts "  $ touch #{keys_file.path}"
+    end
+
+    def print_github_user_does_not_exist(username)
+      puts "Github user '#{username}' does not exist"
+    end
+
+    def print_github_unavailable
+      puts "Github appears to be unavailable :("
+      puts
+      puts "https://status.github.com"
+    end
+
+    def keys
+      @keys ||= usernames.map { |username| keys_for username }.flatten.compact
+    end
+
+    def keys_for(username)
+      Github::Auth::KeysClient.new(
+        hostname: github_hostname,
+        username: username
+      ).keys
+    rescue Github::Auth::KeysClient::GithubUserDoesNotExistError
+      print_github_user_does_not_exist username
+    rescue Github::Auth::KeysClient::GithubUnavailableError
+      print_github_unavailable
+    end
+
+    def keys_file
+      Github::Auth::KeysFile.new path: keys_file_path
+    end
+
+    def keys_file_path
+      Github::Auth::KeysFile::DEFAULT_PATH
+    end
+
+    def github_hostname
+      Github::Auth::KeysClient::DEFAULT_HOSTNAME
+    end
+  end
+end

data/lib/github/auth/keys_client.rb

@@ -0,0 +1,44 @@
+require 'httparty'
+
+module Github::Auth
+  class KeysClient
+    attr_reader :username, :hostname
+
+    UsernameRequiredError = Class.new StandardError
+    GithubUnavailableError = Class.new StandardError
+    GithubUserDoesNotExistError = Class.new StandardError
+
+    DEFAULT_HOSTNAME = 'https://api.github.com'
+
+    DEFAULT_OPTIONS = {
+      username: nil,
+      hostname: DEFAULT_HOSTNAME
+    }
+
+    def initialize(options = {})
+      options = DEFAULT_OPTIONS.merge options
+      raise UsernameRequiredError unless options.fetch :username
+
+      @username = options.fetch :username
+      @hostname = options.fetch :hostname
+    end
+
+    def keys
+      @keys ||= Array(github_response).map { |entry| entry.fetch 'key' }
+    end
+
+    private
+
+    def github_response
+      response = http_client.get "#{hostname}/users/#{username}/keys"
+        raise GithubUserDoesNotExistError if response.code == 404
+      response.parsed_response
+    rescue SocketError, Errno::ECONNREFUSED => e
+      raise GithubUnavailableError.new e
+    end
+
+    def http_client
+      HTTParty
+    end
+  end
+end

data/lib/github/auth/keys_file.rb

@@ -0,0 +1,57 @@
+module Github::Auth
+  class KeysFile
+    attr_reader :path
+
+    PermissionDeniedError = Class.new StandardError
+    FileDoesNotExistError = Class.new StandardError
+
+    DEFAULT_PATH = '~/.ssh/authorized_keys'
+
+    def initialize(options = {})
+      @path = File.expand_path(options[:path] || DEFAULT_PATH)
+    end
+
+    def write!(keys)
+      append_keys_file do |keys_file|
+        Array(keys).each do |key|
+          keys_file.write "\n#{key}" unless keys_file_content.include? key
+        end
+      end
+    end
+
+    def delete!(keys)
+      new_content = keys_file_content_without keys
+
+      write_keys_file { |keys_file| keys_file.write new_content }
+    end
+
+    private
+
+    def append_keys_file(&block)
+      with_keys_file 'a', block
+    end
+
+    def write_keys_file(&block)
+      with_keys_file 'w', block
+    end
+
+    def with_keys_file(mode, block)
+      File.open(path, mode) { |keys_file| block.call keys_file }
+    rescue Errno::EACCES => e
+      raise PermissionDeniedError.new e
+    rescue Errno::ENOENT => e
+      raise FileDoesNotExistError.new e
+    end
+
+    def keys_file_content
+      File.read path
+    end
+
+    def keys_file_content_without(keys)
+      keys_file_content.tap do |content|
+        Array(keys).each { |key| content.gsub! key, '' }
+        content.strip!
+      end
+    end
+  end
+end

data/lib/github/auth/version.rb

@@ -0,0 +1,5 @@
+module Github
+  module Auth
+    VERSION = "0.1.0"
+  end
+end

data/spec/acceptance/github/auth/cli_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'support/mock_github_server'
+require 'github/auth'
+
+describe Github::Auth::CLI do
+  with_mock_github_server do |mock_server_hostname|
+    let(:hostname) { mock_server_hostname }
+    let(:keys_file) { Tempfile.new 'authorized_keys' }
+    let(:keys) { Github::Auth::MockGithubServer::KEYS }
+
+    after { keys_file.unlink }
+
+    def cli(argv)
+      described_class.new(argv).tap do |cli|
+        cli.stub(
+          github_hostname: hostname,
+          keys_file_path: keys_file.path
+        )
+      end
+    end
+
+    it 'adds and removes keys from the keys file' do
+      cli(%w(add chrishunt)).execute
+
+      keys_file.read.tap do |content|
+        keys.each { |key| expect(content).to include key }
+      end
+
+      cli(%w(remove chrishunt)).execute
+
+      expect(keys_file.read).to be_empty
+
+      keys_file.unlink
+    end
+  end
+end

data/spec/acceptance/github/auth/keys_client_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'support/mock_github_server'
+require 'github/auth'
+
+describe Github::Auth::KeysClient do
+  it 'fetches all keys for the given github user' do
+    with_mock_github_server do |hostname, keys|
+      client = described_class.new(
+        username: 'chrishunt',
+        hostname: hostname
+      )
+
+      expect(client.keys).to eq keys
+    end
+  end
+end

data/spec/acceptance/github/auth/keys_file_spec.rb

@@ -0,0 +1,22 @@
+require 'tempfile'
+require 'spec_helper'
+require 'github/auth'
+
+describe Github::Auth::KeysFile do
+  it 'writes and deletes keys from the keys file' do
+    tempfile  = Tempfile.new 'authorized_keys'
+    keys_file = described_class.new path: tempfile.path
+    keys = %w(abc123 def456)
+
+    keys_file.write! keys
+    expect(tempfile.read).to include keys.join("\n")
+
+    keys_file.delete! keys.first
+    expect(tempfile.read).to_not include keys.first
+
+    keys_file.delete! keys.last
+    expect(tempfile.read).to_not include keys.last
+
+    expect(tempfile.read).to be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'coveralls'
+Coveralls.wear!

data/spec/support/mock_github_server.rb

@@ -0,0 +1,40 @@
+require 'httparty'
+require 'sinatra/base'
+require 'json'
+
+module Github::Auth
+  class MockGithubServer < Sinatra::Base
+    KEYS = %w(abc234 def456)
+
+    set :port, 8001
+
+    get '/' do
+      'success'
+    end
+
+    get '/users/chrishunt/keys' do
+      content_type :json
+
+      [
+        { 'id' => 123, 'key' => KEYS[0] },
+        { 'id' => 456, 'key' => KEYS[1] }
+      ].to_json
+    end
+  end
+end
+
+def with_mock_github_server
+  hostname = "http://localhost:#{Github::Auth::MockGithubServer.port}"
+  Thread.new { Github::Auth::MockGithubServer.run! }
+
+  while true
+    begin
+      HTTParty.get(hostname)
+      break
+    rescue Errno::ECONNREFUSED
+      # Do nothing, try again
+    end
+  end
+
+  yield hostname, Github::Auth::MockGithubServer::KEYS
+end

data/spec/unit/github/auth/cli_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'github/auth/cli'
+
+describe Github::Auth::CLI do
+  let(:argv) { [] }
+
+  subject { described_class.new argv }
+
+  describe '#execute' do
+    shared_examples_for 'a method that prints usage' do
+      it 'prints the usage' do
+        subject.should_receive(:print_usage)
+        subject.execute
+      end
+    end
+
+    context 'when missing a command' do
+      let(:argv) { [] }
+      it_should_behave_like 'a method that prints usage'
+    end
+
+    context 'with an invalid command' do
+      let(:argv) { ['invalid'] }
+      it_should_behave_like 'a method that prints usage'
+    end
+
+    context 'when no usernames are provide' do
+      let(:argv) { ['add'] }
+      it_should_behave_like 'a method that prints usage'
+    end
+
+    context 'with a valid action and usernames' do
+      let(:action) { 'add' }
+      let(:argv) { [action, 'chrishunt'] }
+
+      it 'calls the method matching the action name' do
+        subject.should_receive(action)
+        subject.execute
+      end
+    end
+  end
+end

data/spec/unit/github/auth/keys_client_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'github/auth/keys_client'
+
+describe Github::Auth::KeysClient do
+  subject { described_class.new username: username }
+
+  let(:username) { 'chrishunt' }
+  let(:http_client) { stub('HttpClient', get: response) }
+  let(:response_code) { 200 }
+  let(:parsed_response) { nil }
+  let(:response) {
+    stub('HTTParty::Response', {
+      code: response_code,
+      parsed_response: parsed_response
+    })
+  }
+
+  before { subject.stub(http_client: http_client) }
+
+  describe '#initialize' do
+    it 'requires a username' do
+      expect {
+        described_class.new
+      }.to raise_error Github::Auth::KeysClient::UsernameRequiredError
+
+      expect {
+        described_class.new username: nil
+      }.to raise_error Github::Auth::KeysClient::UsernameRequiredError
+    end
+
+    it 'saves the username' do
+      keys_client = described_class.new username: username
+      expect(keys_client.username).to eq username
+    end
+  end
+
+  describe '#keys' do
+    it 'requests keys from the Github API' do
+      http_client.should_receive(:get).with(
+        "https://api.github.com/users/#{username}/keys"
+      )
+      subject.keys
+    end
+
+    it 'memoizes the response' do
+      http_client.should_receive(:get).once
+      2.times { subject.keys }
+    end
+
+    context 'when the github user has keys' do
+      let(:parsed_response) {[
+        { 'id' => 123, 'key' => 'BLAHBLAH' },
+        { 'id' => 456, 'key' => 'FLARBBLU' }
+      ]}
+
+      it 'returns the keys' do
+        expected_keys = parsed_response.map { |entry| entry.fetch 'key' }
+        expect(subject.keys).to eq expected_keys
+      end
+    end
+
+    context 'when the github user does not have keys' do
+      let(:parsed_response) { [] }
+
+      it 'returns an empty array' do
+        expect(subject.keys).to eq []
+      end
+    end
+
+    context 'when the github user does not exist' do
+      let(:response_code) { 404 }
+
+      it 'raises GithubUserDoesNotExistError' do
+        expect {
+          subject.keys
+        }.to raise_error Github::Auth::KeysClient::GithubUserDoesNotExistError
+      end
+    end
+
+    context 'when there is an issue connecting to Github' do
+      [SocketError, Errno::ECONNREFUSED].each do |exception|
+        before { http_client.stub(:get).and_raise exception }
+
+        it 'raises a GithubUnavailableError' do
+          expect {
+            subject.keys
+          }.to raise_error Github::Auth::KeysClient::GithubUnavailableError
+        end
+      end
+    end
+  end
+end

data/spec/unit/github/auth/keys_file_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'tempfile'
+require 'github/auth/keys_file'
+
+describe Github::Auth::KeysFile do
+  subject { described_class.new path: path }
+
+  let(:keys) { %w(abc123 def456) }
+  let(:keys_file) { Tempfile.new 'authorized_keys' }
+  let(:path) { keys_file.path }
+
+  after { keys_file.unlink } # clean up, delete tempfile
+
+  describe '#initialize' do
+    context 'without a path' do
+      let(:path) { nil }
+
+      it 'has a default path' do
+        expect(subject.path).to_not be_nil
+      end
+    end
+
+    context 'with a custom path' do
+      let(:path) { '/foo/bar/baz' }
+
+      it 'saves the custom path' do
+        expect(subject.path).to eq path
+      end
+    end
+
+    context 'with an unexpanded path' do
+      let(:path) { '~/my/home/dir' }
+
+      it 'expands the path' do
+        expect(subject.path).to_not include '~'
+      end
+    end
+  end
+
+  describe '#write!' do
+    it 'writes each key to the keys file' do
+      subject.write! keys
+      file_content = keys_file.read
+      keys.each { |key| expect(file_content).to include key }
+    end
+
+    context 'with a single key' do
+      let(:key) { 'abc123' }
+
+      it 'writes the single key to the keys file' do
+        subject.write! key
+        expect(keys_file.read).to include key
+      end
+    end
+
+    context 'with existing keys in the keys file' do
+      let(:existing_keys) { %w(ghi789 jkl123) }
+
+      before do
+        keys_file.write existing_keys.join("\n")
+        keys_file.rewind
+      end
+
+      it 'preserves the existing keys' do
+        subject.write! keys
+        file_lines = keys_file.readlines
+        existing_keys.each { |key| expect(file_lines).to include "#{key}\n" }
+      end
+
+      it 'does not write duplicate keys into the keys file' do
+        subject.write! existing_keys.first
+        expect(keys_file.readlines.count).to eq existing_keys.count
+      end
+    end
+
+    context 'when the keys file is readonly' do
+      before { File.chmod(0400, keys_file) }
+
+      it 'raises PermissionDeniedError' do
+        expect {
+          subject.write! keys
+        }.to raise_error Github::Auth::KeysFile::PermissionDeniedError
+      end
+    end
+
+    context 'when the keys file does not exist' do
+      let(:path) { 'not/a/real/file/path' }
+
+      it 'raises FileDoesNotExistError' do
+        expect {
+          subject.write! keys
+        }.to raise_error Github::Auth::KeysFile::FileDoesNotExistError
+      end
+    end
+  end
+
+  describe '#delete!' do
+    before do
+      keys_file.write keys.join("\n")
+      keys_file.rewind
+    end
+
+    context 'when the keys file has the key' do
+      let(:key) { keys[0] }
+      let(:other_key) { keys[1] }
+
+      it 'removes the key from the keys file' do
+        subject.delete! key
+        expect(keys_file.read).to_not include key
+      end
+
+      it 'does not remove the other key from the keys file' do
+        subject.delete! key
+        expect(keys_file.read).to include other_key
+      end
+
+      it 'does not leave blank lines' do
+        subject.delete! [key, other_key]
+        blank_lines = keys_file.readlines.select { |line| line =~ /^$\n/ }
+
+        expect(blank_lines).to be_empty
+      end
+    end
+
+    context 'when the keys file does not have the key' do
+      let(:key) { 'not-in-the-keys-file' }
+
+      it 'does not modify the keys file' do
+        original_keys_file = keys_file.read
+        keys_file.rewind
+
+        subject.delete! key
+
+        expect(keys_file.read).to eq original_keys_file
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: github-auth
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: SSH key management for Github users
+email:
+- c@chrishunt.co
+executables:
+- gh-auth
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/gh-auth
+- github-auth.gemspec
+- img/mac-os-ssh-sharing.png
+- lib/github/auth.rb
+- lib/github/auth/cli.rb
+- lib/github/auth/keys_client.rb
+- lib/github/auth/keys_file.rb
+- lib/github/auth/version.rb
+- spec/acceptance/github/auth/cli_spec.rb
+- spec/acceptance/github/auth/keys_client_spec.rb
+- spec/acceptance/github/auth/keys_file_spec.rb
+- spec/spec_helper.rb
+- spec/support/mock_github_server.rb
+- spec/unit/github/auth/cli_spec.rb
+- spec/unit/github/auth/keys_client_spec.rb
+- spec/unit/github/auth/keys_file_spec.rb
+homepage: https://github.com/chrishunt/github-auth
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: SSH key management for Github users
+test_files:
+- spec/acceptance/github/auth/cli_spec.rb
+- spec/acceptance/github/auth/keys_client_spec.rb
+- spec/acceptance/github/auth/keys_file_spec.rb
+- spec/spec_helper.rb
+- spec/support/mock_github_server.rb
+- spec/unit/github/auth/cli_spec.rb
+- spec/unit/github/auth/keys_client_spec.rb
+- spec/unit/github/auth/keys_file_spec.rb