gas 0.1.7 → 0.1.8

data/lib/gas/settings.rb

@@ -0,0 +1,28 @@
+module Gas
+
+  # Class that contains settings for the app
+  class Settings
+    attr_accessor :base_dir, :github_server
+    attr_reader :gas_dir, :ssh_dir
+
+    def initialize
+      @base_dir = '~'
+      @gas_dir = "#{@base_dir}/.gas"
+      @ssh_dir = "#{@base_dir}/.ssh"
+      @github_server = 'api.github.com'
+    end
+
+    def configure
+      yield self if block_given?
+    end
+
+    def gas_dir=(value)
+      @gas_dir = "#{@base_dir}/#{value}"
+    end
+
+    def ssh_dir=(value)
+      @ssh_dir = "#{@base_dir}/#{value}"
+    end
+
+  end
+end

data/lib/gas/ssh.rb

@@ -1,42 +1,10 @@
 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
-
+    require 'digest/md5'
+    extend Prompter
 
     def self.corresponding_rsa_files_exist?(nickname = '')
       nickname = @uid if nickname  == ''
@@ -44,60 +12,27 @@ module Gas
       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`
+      FileUtils.cp("#{SSH_DIRECTORY}/id_rsa", "#{GAS_DIRECTORY}/#{@uid}_id_rsa")
+      FileUtils.cp("#{SSH_DIRECTORY}/id_rsa.pub", "#{GAS_DIRECTORY}/#{@uid}_id_rsa.pub")
+      FileUtils.chmod 0700, "#{GAS_DIRECTORY}/#{@uid}_id_rsa"
+      FileUtils.chmod 0700, "#{GAS_DIRECTORY}/#{@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}")
 
@@ -120,124 +55,61 @@ module Gas
       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?
+      if Gas::Prompter.user_wants_gas_to_handle_rsa_keys?
+        if corresponding_rsa_files_exist?(@uid) and Gas::Prompter.user_wants_to_use_key_already_in_gas?(@uid)
           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?"
+        elsif !corresponding_rsa_files_exist?(@uid) and ssh_dir_contains_rsa? and Gas::Prompter.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.
+      else # !Gas::Prompter.user_wants_gas_to_handle_rsa_keys?
+        # check if ~/.gas/rsa exists, if it does, promt the user
+        # because that key must be destroyed (if the user really doesn't want gas handling keys for this user)
+        if corresponding_rsa_files_exist?(@uid) #in ~/.gas/
+          delete_associated_local_keys!(@uid) if Gas::Prompter.user_wants_to_remove_the_keys_that_already_exist_for_this_user?(@uid)
+        end
       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 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
+            if Gas::Prompter.user_wants_to_overwrite_existing_rsa_key?
+              write_to_ssh_dir!
+            else
+              puts "Proceeding without swapping rsa keys (aborting)."
             end
-
           end
-
-        else # if no ~/.ssh/id_rsa exists... no overwrite potential
+        else # if no ~/.ssh/id_rsa exists... no overwrite potential... so just write away
           write_to_ssh_dir!
         end
-
       end
     end
 
-
+    
     def self.write_to_ssh_dir!
+      supress_process_output = "> /dev/null 2>&1"
+      supress_process_output = "> NUL" if IS_WINDOWS
+
       # 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?
+      system("ssh-add -d #{SSH_DIRECTORY}/id_rsa #{supress_process_output}") 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")
@@ -246,23 +118,24 @@ module Gas
       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
+        `ssh-add #{SSH_DIRECTORY}/id_rsa #{supress_process_output}`  # 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 == 1    # exit status 1 means failed
+          puts "Looks like there may have been a fatal error in registering the rsa key with ssh-agent.  Might be worth looking into"
+          raise "Exit code on ssh-add command line was one meaning: Error!"
         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
+    # 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)
@@ -274,7 +147,6 @@ module Gas
       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
@@ -285,243 +157,74 @@ module Gas
 
     def self.get_md5_hash(file_path)
       if File.exists? file_path
-        return Digest::MD5.hexdigest(File.open(file_path, "rb").read)
+        file = File.open(file_path, "rb")
+        hash = Digest::MD5.hexdigest(file.read)
+        file.close
+        return hash
       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!
+    def self.upload_public_key_to_github(user, github_speaker = nil)
+      if Gas::Prompter.user_wants_to_install_key_to_github?
+        key_installation_routine!(user, nil, github_speaker)
       end
     end
 
-
-    def self.key_installation_routine!(user = nil, rsa_test = nil)
+    
+    def self.key_installation_routine!(user = nil, rsa_test = nil, github_speaker = nil)
       @uid = user.nickname unless user.nil?      # allows for easy testing
 
-      rsa_key = get_associated_rsa_key(@uid)
+      rsa_key = get_associated_rsa_key(@uid).first
       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
+      github_speaker = GithubSpeaker.new(user) if github_speaker.nil?
+      
+      puts github_speaker.status
 
-      if !credentials
+      if github_speaker.status == :bad_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)
+      
+      result = github_speaker.post_key!(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
+    # Get's the ~/.gas/user_id_rsa and ~/.gas/user_id_rsa.pub strings associated with 
+    # the specified user and returns it as an array.  Returns array with two nils if there's no keys
+    # [pub_rsa, priv_rsa]
     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
+      pub_path = "#{GAS_DIRECTORY}/#{nickname}_id_rsa.pub"
+      priv_path = "#{GAS_DIRECTORY}/#{nickname}_id_rsa"
+
+      if File.exists? pub_path and File.exists? priv_path
+        pub_file = File.open(pub_path, "rb")
+        pub_rsa = pub_file.read.strip
+        pub_file.close
+        if pub_rsa.count(' ') == 2             # special trick to split off the trailing comment text because github API won't store it.
+          pub_rsa = pub_rsa.split(" ")
+          pub_rsa = "#{rsa[0]} #{rsa[1]}"
         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
-
+        
+        priv_file = File.open(priv_path, "rb")
+        priv_rsa = priv_file.read.strip
+        priv_file.close
 
-    # 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
+        return [pub_rsa, priv_rsa]
       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
+      return [nil, nil]
     end
 
-
     # Cross-platform way of finding an executable in the $PATH.
     # returns nil if command not present
     #
@@ -546,7 +249,7 @@ module Gas
     def self.delete(nickname)
       return false unless user_has_ssh_keys?(nickname)  # return if no keys
 
-      case user_wants_to_delete_all_ssh_data?
+      case Gas::Prompter.user_wants_to_delete_all_ssh_data?
       when "a"
         delete_associated_github_keys!(nickname)
         delete_associated_local_keys!(nickname)
@@ -561,21 +264,24 @@ module Gas
     end
 
     def self.user_has_ssh_keys?(nickname)
-      return false if get_associated_rsa_key(nickname).nil?
+      return false if get_associated_rsa_key(nickname).first.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)
+      rsa = get_associated_rsa_key(nickname).first
+      
+      credentials = get_nils
+      
+      github_speaker = GithubSpeaker.new(nickname, credentials[:username], credentials[:password])
+      
+      result = github_speaker.remove_key! rsa
       puts "The key for this user was not in the specified github account's public keys section." if !result
     end
-
+    
+    # this is just for testing... it gets stubbed... otherwise, the nils are normal and allow for
+    # normal prompting for username and password from within the GithubSpeaker class
+    def self.get_nils; { :username => nil, :password => nil };end
 
     def self.delete_associated_local_keys!(nickname)
       puts "Removing associated keys from local machine..."
@@ -594,37 +300,6 @@ module Gas
       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
-
-
+end