gas 0.1.6 → 0.1.7

data/README.textile

@@ -4,7 +4,7 @@ h1. gas - manage your git author accounts
 
 h2. Description
 
-Gas is a utility to keep track of your git authors. Add them to gas and switch at any time. Great if you use one author at work and one at home for instance.
+Gas is a mighty utility that helps you keep track of your multiple git authors.  Add them to gas and switch between them instantly!  Great if you use one author at work and one at home or if you are doing pair programming.  
 
 h2. Installation
 
@@ -20,19 +20,19 @@ $ rake install
 
 h2. Running
 
-Default task is to list authors
+The default task is to list authors
 
 bc. $ gas
 
 bc. $ gas list
 
-This lists the authors that are set up.
+This lists the authors that are set up in the ~/.gas/gas.authors file.
 
 You can import your current user by giving it a nickname
 
 bc. $ gas import current_user
 
-To add a author use, add
+To add an author use, add
 
 bc. $ gas add walle "Fredrik Wallgren" fredrik.wallgren@gmail.com
 
@@ -44,4 +44,10 @@ To delete it again use, delete
 
 bc. $ gas delete walle
 
+Gas can also juggle your id_rsa ssh keys, which is helpful for uploading to github between multiple accounts.  Indespensible for teachers who need to instruct their students on how to use github!
+
+bc. $ gas add Njax NotarySojac no@mail.com
+Do you want gas to handle switching rsa keys for this user?
+[y/n]
+
 View @gas -h@ to see all options.

data/bin/gas

@@ -36,6 +36,11 @@ class GasRunner < Thor
   def delete(nickname)
     Gas.delete nickname
   end
+  
+  desc "ssh", "Creates a new ssh key for an existing gas author"
+  def ssh(nickname=nil)
+    Gas.ssh nickname
+  end
 
   desc "version", "Prints Gas's version"
   def version

data/lib/gas.rb

@@ -1,8 +1,17 @@
+GAS_DIRECTORY = File.expand_path('~/.gas')
+SSH_DIRECTORY = File.expand_path('~/.ssh')
+GITHUB_SERVER = 'api.github.com'
+
+
+require 'sshkey' #external
+
 require 'gas/version'
+require 'gas/ssh'
 require 'gas/user'
 require 'gas/config'
 require 'gas/gitconfig'
 
+
 module Gas
 
   @config = Config.new
@@ -10,10 +19,13 @@ module Gas
 
   # Lists all authors
   def self.list
+    puts
     puts 'Available users:'
+    puts
     puts @config
+    puts
 
-    self.show
+    # self.show  # XXX: get rid of
   end
 
   # Shows the current user
@@ -33,9 +45,9 @@ module Gas
   def self.use(nickname)
     self.no_user? nickname
     user = @config[nickname]
-
-    @gitconfig.change_user user.name, user.email
-
+    
+    @gitconfig.change_user user        # daring change made here!  Heads up Walle
+    
     self.show
   end
 
@@ -44,14 +56,54 @@ module Gas
   # @param [String] name The name of the author
   # @param [String] email The email of the author
   def self.add(nickname, name, email)
-    self.has_user? nickname
+    return false if self.has_user?(nickname)
     user = User.new name, email, nickname
     @config.add user
     @config.save!
-
-    puts 'Added author'
+    
+    using_ssh = Ssh.setup_ssh_keys user
+    
+    Ssh.upload_public_key_to_github(user) if using_ssh
+    
+    puts 'Added new author'
     puts user
   end
+  
+  
+  # Adds an ssh key for the specified user
+  def self.ssh(nickname)
+    if nickname.nil?
+      puts "Oh, so you'd like an elaborate explanation on how ssh key juggling works?  Well pull up a chair!"
+      puts
+      puts "Gas can juggle ssh keys for you.  It works best in a unix based environment (so at least use git bash or cygwin on a windows platform)."
+      puts "You will be prompted if you would like to handle SSH keys when you create a new user."
+      puts "If you are a long time user of gas, you can add ssh to an author by the command..."
+      puts "\$  gas ssh NICKNAME"
+      puts
+      puts "Your ssh keys will be stored in ~/.gas/NICKNAME_id_rsa and automatically copied to ~/.ssh/id_rsa when you use the command..."
+      puts "\$  gas use NICKNAME"
+      puts "If ~/.ssh/id_rsa already exists, you will be prompted UNLESS that rsa file is already backed up in the .gas directory (I'm so sneaky, huh?)"
+      puts
+      puts "The unix command ssh-add is used in order to link up your rsa keys when you attempt to make an ssh connection (git push uses ssh keys of course)"
+      puts
+      puts "The ssh feature of gas offers you and the world ease of use, and even marginally enhanced privacy against corporate databases.  Did you know that IBM built one of the first automated database systems?  These ancient database machines (called tabulators) were used to facilitate the holocaust =("
+    else
+      user = @config[nickname]
+      
+      
+      # Prompt Remake this user's ssh keys?
+      
+      # check for ssh keys
+      if !Ssh.corresponding_rsa_files_exist?(nickname)
+        Ssh.setup_ssh_keys user
+        Ssh.upload_public_key_to_github user
+      else  
+        Ssh.setup_ssh_keys user
+        Ssh.upload_public_key_to_github user
+      end
+    end
+  end
+  
 
   # Imports current user from .gitconfig to .gas
   # @param [String] nickname The nickname to give to the new user
@@ -72,14 +124,24 @@ module Gas
     end
   end
 
-  # Deletes a author from the config using nickname
+  # Deletes an author from the config using nickname
   # @param [String] nickname The nickname of the author
   def self.delete(nickname)
-    self.no_user? nickname
+    
+    return false unless self.no_user? nickname        # I re-engineered this section so I could use Gas.delete in a test even when that author didn't exist
+                                                      # TODO: The name no_user? is now very confusing.  It should be changed to something like "is_user?" now maybe?
+    
+    Ssh.delete nickname  # XXX: there are 2 calls to this in the method!  
+    
+    
+    # exit
     @config.delete nickname
     @config.save!
+    
+    #Ssh.delete nickname   # TODO: delete this duplicate after...
 
     puts "Deleted author #{nickname}"
+    return true
   end
 
   # Prints the current version
@@ -92,17 +154,19 @@ module Gas
   def self.no_user?(nickname)
     if !@config.exists? nickname
       puts "Nickname #{nickname} does not exist"
-      exit
+      return false
     end
+    return true
   end
 
   # Checks if the user exists and gives error and exit if so
   # @param [String] nickname
   def self.has_user?(nickname)
     if @config.exists? nickname
-      puts "Nickname #{nickname} does already exist"
-      exit
+      puts "Nickname #{nickname} already exists"
+      return true
     end
+    return false
   end
 
 end

data/lib/gas/config.rb

@@ -6,15 +6,42 @@ module Gas
   class Config
     attr_reader :users
 
+    # This function checks for a ~/.gas FILE and if it exists, it puts it into memory and deletes it from the HDD
+    # then it creates the ~/.gas FOLDER and saves the old .gas file as ~/git.conf
+    #
+    def migrate_to_gas_dir!
+      old_config_file = File.expand_path('~/.gas')
+      config_dir = File.expand_path('~/.gas')
+      new_config_file = File.expand_path('~/.gas') + "/gas.authors"
+
+      if File.file? old_config_file
+        file = File.open(old_config_file, "rb")
+        contents = file.read
+        file.close
+
+        File.delete old_config_file
+
+        Dir::mkdir(config_dir)
+
+        file = File.new(new_config_file, "w")
+        file.puts contents
+        file.close
+      end
+    end
+
+
     # Initializes the object. If no users are supplied we look for a config file, if none then create it, and parse it to load users
     # @param [Array<User>] users The override users
     # @param [String] config The override config
     def initialize(users = nil, config = nil)
-      @config_file = File.expand_path('~/.gas')
+      migrate_to_gas_dir! # Migrates old users to the new configuration file location, how thoughtful of me, I know
+      @config_file = File.expand_path('~/.gas/gas.authors')
+      @gas_dir = File.expand_path('~/.gas')
       @config = ''
 
       if config.nil?
         if !File.exists? @config_file
+          Dir::mkdir(@gas_dir)
           FileUtils.touch @config_file
         end
 
@@ -87,9 +114,34 @@ module Gas
       end
     end
 
+
     # Override to_s to output correct format
     def to_s
-      @users.join("\n")
+      gc = Gitconfig.new
+
+      users = @users.map do |user|
+        if is_current_user(gc.current_user_object[:name], gc.current_user_object[:email], user.to_s)
+          "  ==>" + user.to_s[5,user.to_s.length]
+        else
+          user.to_s
+        end
+      end.join("\n")
+
+      return users
+    end
+
+
+    # Scans the @users (a string containing info formatted identical to the gas.author file)
+    #  ...and checks to see if it's name and email match what you're looking for
+    def is_current_user(name, email, object)
+      object.scan(/\[(.+)\]\s+name = (.+)\s+email = (.+)/) do |nicknamec, namec, emailc|
+        if namec == name and emailc == email
+          #  check if ssh is active
+          # TODO:  Check if its SSH key is setup, and indicate SSH ACTIVE
+          return true
+        end
+      end
+      return false   # could not get a current user's nickname
     end
 
   end

data/lib/gas/gitconfig.rb

@@ -2,7 +2,7 @@ module Gas
 
   # Class that class that interacts with the git config
   class Gitconfig
-
+    @@nickname = ''
     # Parse out the current user from the gitconfig
     # @param [String] gitconfig The git configuration
     # @return [User] The current user or nil if not present
@@ -12,15 +12,33 @@ module Gas
 
       return nil if name.nil? && email.nil?
 
-      User.new name.delete("\n"), email.delete("\n") # git cli returns the name and email with \n at the end
+      User.new name.delete("\n"), email.delete("\n"), @@nickname   # git cli returns the name and email with \n at the end
+    end
+
+    # Get current user
+    def current_user_object
+      name = `git config --global --get user.name`
+      email = `git config --global --get user.email`
+
+      return nil if name.nil? && email.nil?
+
+      return {:name => name.strip, :email => email.strip}
     end
 
     # Changes the user
     # @param [String] name The new name
     # @param [String] email The new email
-    def change_user(name, email)
+    def change_user(user)
+      nickname = user.nickname
+      @@nickname = nickname                  # maybe we should make nickname a class variable?
+      name = user.name
+      email = user.email
+
       `git config --global user.name "#{name}"`
       `git config --global user.email "#{email}"`
+
+      # confirm that this user has an ssh and if so, swap it in safely
+      Ssh.swap_in_rsa nickname
     end
 
   end

data/lib/gas/ssh.rb

@@ -0,0 +1,630 @@
+module Gas
+
+  class Ssh
+    require 'highline/import'
+    require 'net/https'
+    require 'json'
+
+
+    # If the user says 'f', the system will
+    #   report that there isn't an id_rsa already in gas.  This causes a new key to overwrite automatically down the road.
+    # This is for checking if a .gas/rsa file already exists for a nickname which is being registered
+    # If the rsa exists, then we're goona need to ask if we should use it, or if we should delete it
+    #
+    # Returns true to indicate that the user would like to use the rsa file already in .gas ()
+    # Returns false when there is no naming conflicts.
+    def self.user_wants_to_use_key_already_in_gas?
+      if corresponding_rsa_files_exist?
+        puts "Gas has detected a key in its archive directory ~/.gas/#{@uid}_id_rsa.  Should gas use this key or overwrite this key with a brand new one?"
+        puts "Keep current key? [y/n]"
+
+        while true
+          keep_current_file = STDIN.gets.strip
+
+          case keep_current_file
+
+          when "y"
+            return true # keep the files already in .gas, skip making key.
+          when "n"
+            return false
+          else
+            puts "please respond 'y' or 'n'"
+          end
+        end
+
+      else # no need to do anything if files don't exist
+        return false
+      end
+    end
+
+
+    def self.corresponding_rsa_files_exist?(nickname = '')
+      nickname = @uid if nickname  == ''
+      return true if File.exists? "#{GAS_DIRECTORY}/#{nickname}_id_rsa" and File.exists? "#{GAS_DIRECTORY}/#{nickname}_id_rsa.pub"
+      false
+    end
+
+
+    # Copies a key pair from ~/.ssh to .gas/Nickname*
+    def self.use_current_rsa_files_for_this_user(test = nil)
+      @uid = test unless test.nil?
+      cmd_result = `cp ~/.ssh/id_rsa ~/.gas/#{@uid}_id_rsa`
+      cmd_result = `cp ~/.ssh/id_rsa.pub ~/.gas/#{@uid}_id_rsa.pub`
+      return true
+    end
+
+
+    def self.ssh_dir_contains_rsa?
+      return true if File.exists?(SSH_DIRECTORY + "/id_rsa") or File.exists?(SSH_DIRECTORY + "/id_rsa.pub")
+      return false
+    end
+
+
+
+    #  Checks if the ~/.ssh directroy contains id_rsa and id_rsa.pub
+    #  if it does, it asks the user if they would like to use that as their ssh key, instead of generating a new key pair.
+    #
+    def self.user_wants_to_use_key_already_in_ssh?
+      return false unless ssh_dir_contains_rsa?
+
+      #puts "Gas has detected that an ~/.ssh/id_rsa file already exists.  Would you like to use this as your ssh key to connect with github?  Otherwise a new key will be generated and stored in ~/.gas (no overwrite concerns until you 'gas use nickname')"
+      puts "Generate a brand new ssh key pair?  (Choose 'n' to use key in ~/.ssh/id_rsa)"
+      puts "Default: 'y'"
+      puts "[Y/n]"
+
+      while true
+        generate_new_rsa = STDIN.gets.strip.downcase
+        case generate_new_rsa
+          when "y", ""
+            return false
+          when "n"
+            return true # return true if we aren't generating a new key
+          else
+            puts "plz answer 'y' or 'n'"
+        end
+      end
+    end
+
+
+
+    # Generates a new sshkey putting it in ~/.gas/nickname_id_rsa
+    # This function can get a little tricky.  It's best to strip off the comment here,
+    # because github API doesn't retain the comment...
+    def self.generate_new_rsa_keys_in_gas_dir
+      puts "Generating new ssh key..."
+      # TODO: Prompt user if they'd like to use a more secure password if physical security to their computer is not possible (dumb imo)... Unless we do that thing where we store keys on github!
+
+      # Old ssh key method (relies on unix environment)
+      # puts `ssh-keygen -f ~/.gas/#{@uid}_id_rsa -t rsa -C "#{@email}" -N ""`    # ssh-keygen style key creation
+
+      # new sshkey gem method...
+      begin
+        k = SSHKey.generate()         #   (:comment => "#{@email}")
+
+        publ = k.ssh_public_key
+        privl = k.private_key
+
+        my_file_privl = File.open(GAS_DIRECTORY + "/#{@uid}_id_rsa",'w',0700)
+        my_file_privl.write(privl)
+        my_file_privl.close
+
+        my_file_publ = File.open(GAS_DIRECTORY + "/#{@uid}_id_rsa.pub",'w',0700)
+        my_file_publ.write(publ)
+        my_file_publ.close
+
+        return true
+      rescue
+        puts "Fatal Error:  Something unexpected happened while writing to #{GAS_DIRECTORY}/#{@uid}_id_rsa"
+        puts "SSH key not saved."
+        return false
+      end
+    end
+
+
+
+    def self.user_wants_gas_to_handle_rsa_keys?
+      puts "Do you want gas to handle switching rsa keys for this user?"
+      puts "[Y/n]"
+
+      while true
+        handle_rsa = STDIN.gets.strip
+
+        case handle_rsa
+        when "y", ""
+          return true
+        when "n"
+          puts
+          # check if ~/.gas/rsa exists, if it does, promt the user
+          if corresponding_rsa_files_exist? #in ~/.gas/
+
+            puts "Well... there's already a ~/.gas/#{@uid}_id_rsa configured and ready to go.  Are you sure you don't want gas to handle rsa switching?  (Clicking no will delete the key from the gas directory)"
+            puts "Just let gas handle ssh key for this user? [y/n]"
+
+            while true
+              keep_file = STDIN.gets.strip
+
+              case keep_file
+              when "n"
+                delete "~/.gas/#{@uid}_id_rsa", "~/.gas/#{@uid}_id_rsa.pub"
+                return false
+              when "y"
+                puts "Excelent!  Gas will handle rsa keys for this user."
+                return nil
+              else
+                puts "Please use 'y' or 'n' or enter to choose default."
+              end
+            end
+          end
+          return false
+
+        else
+          puts "Please use 'y' or 'n'"
+        end
+      end
+
+
+    end
+
+    # This function creates the ssh keys if needed and puts them in ~/.gas/NICKNAME_id_rsa and ...rsa.pub
+    #
+    #
+    def self.setup_ssh_keys(user)
+      @uid = user.nickname
+      @email = user.email
+
+      wants_gas_handling_keys = user_wants_gas_to_handle_rsa_keys?
+
+      if wants_gas_handling_keys
+        puts
+
+        if user_wants_to_use_key_already_in_gas?
+          return true  # We don't need to do anything because the .gas directory is already setup
+        elsif user_wants_to_use_key_already_in_ssh?   #  Check ~/.ssh for a current id_rsa file, if yes, "Do you want to use the current id_rsa file to be used as your key?"
+          use_current_rsa_files_for_this_user    # copies the keys from ~/.ssh instead of generating new keys if desired/possible
+          return true
+        else
+          return generate_new_rsa_keys_in_gas_dir
+        end
+
+      elsif wants_gas_handling_keys.nil?
+        return true  # if user_wants_gas_to_handle_rsa_keys? returns nill that means the user actually had ssh keys already in .gas, and they would like to use those.
+      else
+        return false # if user doesn't want gas to use ssh keys, that's fine too.
+      end
+
+    end
+
+
+    # This huge method handles the swapping of id_rsa files on the hdd
+    #
+    def self.swap_in_rsa(nickname)
+      @uid = nickname  # woah, this is extremely sloppy I think... in order to use any other class methods,
+                       #  I need to write to @uid or it will
+                       #  Have the dumb information from the last time it registered a new git author?
+
+      if Ssh.corresponding_rsa_files_exist?
+
+        if ssh_dir_contains_rsa?
+          if current_key_already_backed_up?
+            write_to_ssh_dir!
+          else
+            puts "~/.ssh/id_rsa already exists.  Overwrite?"
+            puts "[y/n]"
+
+            while true
+              overwrite = STDIN.gets.strip
+              case overwrite
+                when "y"
+                  write_to_ssh_dir!
+                  break
+                when "n"
+                  puts "Proceeding without swapping rsa keys."
+                  break
+                else
+                  puts "please respond 'y' or 'n'"
+              end
+            end
+
+          end
+
+        else # if no ~/.ssh/id_rsa exists... no overwrite potential
+          write_to_ssh_dir!
+        end
+
+      end
+    end
+
+
+    def self.write_to_ssh_dir!
+      # remove the current key from the ssh-agent session (key will no longer be used with github)
+      system('ssh-add -d ~/.ssh/id_rsa > /dev/null 2>&1') if is_ssh_agent_there?
+
+      FileUtils.cp(GAS_DIRECTORY + "/#{@uid}_id_rsa", SSH_DIRECTORY + "/id_rsa")
+      FileUtils.cp(GAS_DIRECTORY + "/#{@uid}_id_rsa.pub", SSH_DIRECTORY + "/id_rsa.pub")
+
+      FileUtils.chmod(0700, SSH_DIRECTORY + "/id_rsa")
+      FileUtils.chmod(0700, SSH_DIRECTORY + "/id_rsa.pub")
+
+      if is_ssh_agent_there?
+        `ssh-add ~/.ssh/id_rsa > /dev/null 2>&1`  # you need to run this command to get the private key to be set to active on unix based machines.  Not sure what to do for windows yet...
+        if $?.exitstatus != 0
+          raise "Exit code on ssh-add command line was not zero!"
+          puts "Looks like there may have been a fatal error in registering the rsa key with ssh-agent.  Might be worth looking into" if result != true
+        end
+      else
+        puts "Slight Error:  The key should now be in ~/.ssh so that's good, BUT ssh-add could not be found.  If you're using windows, you'll need to use git bash or cygwin to emulate this unix command and actually do uploads."
+      end
+    end
+
+
+    # This function scans each file in a directory to check to see if it is the same file which it's being compared against
+    # dir_to_scan        The target directory you'd like to scan
+    # file_to_compare    The file's path that you're expecting to find
+    def self.scan_for_file_match(file_to_compare, dir_to_scan)
+      require 'digest/md5'
+
+      pattern = get_md5_hash(file_to_compare)
+
+      @files = Dir.glob(dir_to_scan + "/*" + file_to_compare.split(//).last(1).to_s)
+
+      @files.each do |file|
+        return true if get_md5_hash(file) == pattern
+      end
+
+      return false
+    end
+
+
+    def self.current_key_already_backed_up?
+      if scan_for_file_match(SSH_DIRECTORY + "/id_rsa", GAS_DIRECTORY) and scan_for_file_match(SSH_DIRECTORY + "/id_rsa.pub", GAS_DIRECTORY)
+        return true
+      else
+        return false
+      end
+    end
+
+    def self.get_md5_hash(file_path)
+      if File.exists? file_path
+        return Digest::MD5.hexdigest(File.open(file_path, "rb").read)
+      end
+      return nil
+    end
+
+
+    def self.user_wants_to_install_key_to_github?
+      puts "Gas can automatically install this ssh key into the github account of your choice.  Would you like gas to do this for you?  (Requires inputting github username and password)"
+      puts "[Y/n]"
+
+      while true
+        upload_key = STDIN.gets.strip.downcase
+        case upload_key
+        when "y", ""
+          return true
+        when "n"
+          return false
+        else
+          puts "Plz respond 'y' or 'n'"
+        end
+      end
+    end
+
+
+    def self.upload_public_key_to_github(user)
+      @uid = user.nickname
+
+      if user_wants_to_install_key_to_github?
+        key_installation_routine!
+      end
+    end
+
+
+    def self.key_installation_routine!(user = nil, rsa_test = nil)
+      @uid = user.nickname unless user.nil?      # allows for easy testing
+
+      rsa_key = get_associated_rsa_key(@uid)
+      rsa_key = rsa_test unless rsa_test.nil?
+      return false if rsa_key.nil?
+
+      #  TODO:  Impliment a key ring system where you store your key on your github in a repository, only it's encrypted.  And to decrypt it, there is
+      #    A file in your .gas folder!!!  That sounds SO fun!
+      credentials = get_username_and_password_diligently
+
+      if !credentials
+        puts "Invalid credentials.  Skipping upload of keys to github.  "
+        puts "To try again, type  $  gas ssh #{@uid}"
+        return false
+      end
+
+      result = post_key!(credentials, @uid, rsa_key)
+      if result
+        puts "Key uploaded successfully!"
+        return true
+      end
+    end
+
+
+    # Get's the ~/.gas/user_id_rsa associated with the specified user and returns it as a string
+    def self.get_associated_rsa_key(nickname)
+      file_path = "#{GAS_DIRECTORY}/#{nickname}_id_rsa.pub"
+
+      if File.exists? file_path
+        rsa = File.open(file_path, "rb").read.strip
+        if rsa.count(' ') == 2             # special trick to split off the trailing comment text because github API won't store it.
+          rsa = rsa.split(" ")
+          rsa = "#{rsa[0]} #{rsa[1]}"
+        end
+
+        return rsa
+      end
+      return nil
+    end
+
+
+    def self.get_username_and_password_and_authenticate
+      puts "Type your github.com user name:"
+      print "User: "
+      username = STDIN.gets.strip
+
+      puts "Type your github password:"
+      password = ask("Password: ") { |q| q.echo = false }
+      puts
+
+      credentials = {:username => username, :password => password}
+
+      if valid_github_username_and_pass?(credentials[:username], credentials[:password])
+        return credentials
+      else
+        return false
+      end
+    end
+
+    # Get's the username and password from the user, then authenticates.  If it fails, it asks them if they'd like to try again.
+    # Returns false if aborted
+    def self.get_username_and_password_diligently
+      while true
+        credentials = get_username_and_password_and_authenticate
+        if !credentials
+          puts "Could not authenticate, try again?"
+          puts "y/n"
+
+          again = STDIN.gets.strip
+          case again.downcase
+          when "y"
+          when "n"
+            return false
+          end
+        else
+          return credentials
+        end
+      end
+    end
+
+
+    def self.valid_github_username_and_pass?(username, password)
+      path = '/user'
+
+      http = Net::HTTP.new(GITHUB_SERVER,443)
+      http.use_ssl = true
+
+      req = Net::HTTP::Get.new(path)
+      req.basic_auth username, password
+      response = http.request(req)
+
+      result = JSON.parse(response.body)["message"]
+
+      return false if result == "Bad credentials"
+      return true
+    end
+
+
+    def self.post_key!(credentials, nickname, rsa)
+      puts "Posting key to GitHub.com..."
+      rsa_key = rsa
+      username = credentials[:username]
+      password = credentials[:password]
+
+
+      #  find key...
+      if has_key(username, password, rsa_key)
+        puts "Key already installed."
+        return false
+      end
+      title = "GAS: #{nickname}"
+      install_key(username, password, title, rsa_key)
+    end
+
+
+    def self.remove_key_by_id!(username, password, id)
+      server = 'api.github.com'
+      path = "/user/keys/#{id}"
+
+
+      http = Net::HTTP.new(server,443)
+      http.use_ssl = true
+      req = Net::HTTP::Delete.new(path)
+      req.basic_auth username, password
+
+      response = http.request(req)
+
+      return true if response.body.nil?
+    end
+
+    # Cycles through github, looking to see if rsa exists as a public key, then deletes it if it does
+    def self.has_key(username, password, rsa)
+      # get all keys
+      keys = get_keys(username, password)
+      # loop through arrays checking against 'key'
+      keys.each do |key|
+          if key["key"] == rsa
+            return true
+          end
+      end
+
+      return false   # key not found
+    end
+
+
+    # Cycles through github, looking to see if rsa exists as a public key, then deletes it if it does
+    def self.remove_key!(username, password, rsa)
+      # get all keys
+      keys = get_keys(username, password)
+      # loop through arrays checking against 'key'
+      keys.each do |key|
+          if key["key"] == rsa
+            return remove_key_by_id!(username, password, key["id"])
+          end
+      end
+
+      return false   # key not found
+    end
+
+    def self.get_keys(username, password)
+      server = 'api.github.com'
+      path = '/user/keys'
+
+
+      http = Net::HTTP.new(server,443)
+      req = Net::HTTP::Get.new(path)
+      http.use_ssl = true
+      req.basic_auth username, password
+      response = http.request(req)
+
+      return JSON.parse(response.body)
+    end
+
+
+    def self.install_key(username, password, title, rsa_key)
+      server = 'api.github.com'
+      path = '/user/keys'
+
+      http = Net::HTTP.new(server, 443)   # 443 for ssl
+      http.use_ssl = true
+
+      req = Net::HTTP::Post.new(path)
+      req.basic_auth username, password
+      req.body = "{\"title\":\"#{title}\", \"key\":\"#{rsa_key}\"}"
+
+      response = http.start {|http| http.request(req) }
+      the_code = response.code
+
+      keys_end = get_keys(username, password).length
+
+      return true if the_code == "201"
+
+      puts "The key you are trying to use already exists in another github user's account.  You need to use another key." if the_code == "already_exists"
+
+      # currently.. I think it always returns "already_exists" even if successful.  API bug.
+      puts "Something may have gone wrong.  Either github fixed their API, or your key couldn't be installed." if the_code != "already_exists"
+
+      #return true if my_hash.key?("errors")   # this doesn't work due to it being a buggy API atm  # false  change me to false when they fix their API
+      puts "Server Response: #{response.body}"
+      return false
+    end
+
+
+    # Cross-platform way of finding an executable in the $PATH.
+    # returns nil if command not present
+    #
+    #   which('ruby') #=> /usr/bin/ruby
+    def self.which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each { |ext|
+          exe = "#{path}/#{cmd}#{ext}"
+          return exe if File.executable? exe
+        }
+      end
+      return nil
+    end
+
+    def self.is_ssh_agent_there?
+      return false if which("ssh-add").nil?
+      return true
+    end
+
+    # deletes the ssh keys associated with a user
+    def self.delete(nickname)
+      return false unless user_has_ssh_keys?(nickname)  # return if no keys
+
+      case user_wants_to_delete_all_ssh_data?
+      when "a"
+        delete_associated_github_keys!(nickname)
+        delete_associated_local_keys!(nickname)
+      when "l"
+        delete_associated_local_keys!(nickname)
+      when "g"
+        delete_associated_github_keys!(nickname)
+      when "n"
+        return false
+      end
+
+    end
+
+    def self.user_has_ssh_keys?(nickname)
+      return false if get_associated_rsa_key(nickname).nil?
+      return true
+    end
+
+
+    def self.delete_associated_github_keys!(nickname)
+      rsa = get_associated_rsa_key(nickname)
+      credentials = get_username_and_password_diligently
+      if !credentials
+        return false
+      end
+      result = remove_key!(credentials[:username], credentials[:password], rsa)
+      puts "The key for this user was not in the specified github account's public keys section." if !result
+    end
+
+
+    def self.delete_associated_local_keys!(nickname)
+      puts "Removing associated keys from local machine..."
+      puts
+
+      ssh_file = get_md5_hash("#{SSH_DIRECTORY}/id_rsa")
+      gas_file = get_md5_hash("#{GAS_DIRECTORY}/#{nickname}_id_rsa")
+
+      return false if gas_file.nil?       # if the gas file doesn't exist, return from this function safely, otherwise both objects could be nil, pass this check, and then fuck up our interpreter with file not found errors
+
+      if ssh_file == gas_file
+        File.delete("#{SSH_DIRECTORY}/id_rsa")
+        File.delete("#{SSH_DIRECTORY}/id_rsa.pub")
+      end
+
+      File.delete("#{GAS_DIRECTORY}/#{nickname}_id_rsa")
+      File.delete("#{GAS_DIRECTORY}/#{nickname}_id_rsa.pub")
+    end
+
+    # This is another prompt function, but it returns a more complicated lexicon
+    #
+    # returns "a", "l", "g", or "n"
+    def self.user_wants_to_delete_all_ssh_data?
+      puts "Would you like to remove all ssh keys too!?!  (github account keys can be removed as well!)"
+      puts "a:  All, the local copy, and checks github too."
+      puts "l:  Remove local keys only."
+      puts "g:  Removes keys from github.com only."
+      puts "n:  Don't remove this users keys."
+      puts "Default: l"
+
+      while true
+        delete_all_keys = STDIN.gets.strip
+
+        case delete_all_keys.downcase
+        when "a"
+          return "a"
+        when "l", ""
+          return "l"
+        when "g"
+          return "g"
+        when "n"
+          return "n"
+        else
+          puts "please use 'a', 'l', 'g' or 'n' for NONE."
+        end
+      end
+    end
+
+  end
+end
+
+