gas 0.1.8 → 1.0.0

data/lib/gas/gitconfig.rb

@@ -1,46 +0,0 @@
-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
-    def current_user
-      name = `git config --global --get user.name`
-      email = `git config --global --get user.email`
-
-      return nil if name.nil? && email.nil?
-
-      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(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
-end
-

data/lib/gas/github_speaker.rb

@@ -1,219 +0,0 @@
-module Gas
-  # A beautiful class that makes working with the github API an enjoyable experience
-  class GithubSpeaker
-    attr_reader :user, :account_name, :password, :keys, :status
-    attr_accessor :server
-    
-    def keys
-      refresh_keys if @keys.nil?
-      @keys
-    end
-    
-    def initialize(user, account_name=nil, password=nil, server = 'api.github.com')
-      @user = user
-      @server = server
-      @keys = nil
-      
-      # sort out username and password...  Make it's own function?
-      if account_name.nil? and password.nil?
-        # Prompt for username and password
-        credentials = get_username_and_password_diligently
-        @account_name = credentials[:account_name]            # this overwrite happens twice to make testing easier...  Stub on get_username, kekeke
-        @password = credentials[:password]
-      else
-        @account_name = account_name
-        @password = password
-        authenticate
-      end
-      
-    end
-    
-    
-    def post_key!(rsa)
-      refresh_keys if @keys.nil? 
-      
-      puts "Posting key to GitHub.com..."
-  
-      #  find key...
-      if has_key(rsa)
-        puts "Key already installed."
-        return false
-      end      
-      title = "GAS: #{@user.nickname}"
-      result = install_key(rsa)
-      
-      if result != false
-        @keys << result
-        return true
-      end
-    end
-    
-    
-    def refresh_keys
-      raise "Attempted to update keys when unable to authenticate credentials with github" if @status != :authenticated
-      
-      path = '/user/keys'
-      
-      http = Net::HTTP.new(@server,443)
-      req = Net::HTTP::Get.new(path)
-      http.use_ssl = true
-      req.basic_auth @account_name, @password
-      response = http.request(req)
-      
-      @keys = JSON.parse(response.body)
-    end
-    
-    
-    # Cycles through github, looking to see if rsa exists as a public key, then deletes it if it does
-    def remove_key!(rsa)
-      refresh_keys
-      
-      # loop through arrays checking against 'key'
-      @keys.each do |key|
-        if key["key"] == rsa
-          return remove_key_by_id!(key["id"])
-        end
-      end
-      
-      return false   # key not found      
-    end
-    
-    
-    private
-      def authenticate
-        path = '/user'
-        
-        http = Net::HTTP.new(@server,443)
-        http.use_ssl = true
-        
-        req = Net::HTTP::Get.new(path)
-        req.basic_auth @account_name, @password
-        response = http.request(req)
-        
-        result = JSON.parse(response.body)["message"]
-        
-        if result == "Bad credentials"
-          @status = :bad_credentials
-          return false
-        else
-          @status = :authenticated
-          return true
-        end
-      end
-      
-      def get_username_and_password_and_authenticate
-        puts "Type your github.com user name:"
-        print "User: "
-        account_name = STDIN.gets.strip
-        
-        puts "Type your github password:"
-        password = ask("Password: ") { |q| q.echo = false }
-        puts
-        
-        credentials = {:account_name => account_name, :password => password}
-        #p credentials
-        @account_name = account_name
-        @password = password
-          
-        if authenticate
-          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 get_username_and_password_diligently
-        while true
-          credentials = get_username_and_password_and_authenticate
-          if credentials == false
-            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 install_key(rsa)
-        require "socket"
-        host_name = Socket.gethostname
-        
-        title = "GAS: #{@user.nickname} \-#{host_name}"
-        
-        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 @account_name, @password
-        req.body = "{\"title\":\"#{title}\", \"key\":\"#{rsa}\"}"
-        
-        response = http.start {|m_http| m_http.request(req) }
-        the_code = response.code
-        
-        key_json = JSON.parse(response.body)
-        
-        return key_json 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 changed 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
-      
-      # Cycles through github, looking to see if rsa exists as a public key, then deletes it if it does
-      def has_key(rsa)
-        refresh_keys if @keys.nil?
-        return false if @keys.empty?
-        
-        # loop through arrays checking against 'key'
-        @keys.each do |key|
-          return true if key["key"] == rsa
-        end
-  
-        return false   # key not found      
-      end
-      
-      def remove_key_by_id!(id)
-        path = "/user/keys/#{id}"
-        
-        http = Net::HTTP.new(@server,443)
-        http.use_ssl = true
-        req = Net::HTTP::Delete.new(path)
-        req.basic_auth @account_name, @password
-        
-        response = http.request(req)
-        
-        if response.body.nil?
-          #@keys = nil  # lame hack! sooo lazy of me.  I should learn how to remove the proper key from the @keys hash...
-          remove_key_from_keys id
-          return true
-        end
-      end
-      
-      
-      def remove_key_from_keys(id_to_delete)
-        @keys.each.with_index do |key, i|
-          @keys.delete_at(i) if key['id'].to_i == id_to_delete.to_i
-        end
-      end
-      
-      
-        
-    
-  end
-end

data/lib/gas/prompter.rb

@@ -1,169 +0,0 @@
-module Gas
-  module Prompter
-    @invalid_input_response_with_default = "Please use 'y' or 'n' or enter for default."
-    # 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 are no naming conflicts.
-    def self.user_wants_to_use_key_already_in_gas?(uid = '')
-      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 = clean_gets
-
-        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
-    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?
-      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 = clean_gets.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 @invalid_input_response_with_default
-        end
-      end
-    end
-    
-    def self.user_wants_gas_to_handle_rsa_keys?
-      puts
-      puts "Do you want gas to handle switching rsa keys for this user?"
-      puts "[Y/n]"
-
-      while true
-        handle_rsa = clean_gets
-
-        case handle_rsa
-        when "y", ""
-          return true
-        when "n"
-          return false
-        else
-          puts "Please use 'y' or 'n'"
-        end
-      end
-    end
-    
-    def self.user_wants_to_remove_the_keys_that_already_exist_for_this_user?(uid)
-      puts
-      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 = clean_gets
-
-        case keep_file
-        when "n"
-          return true
-        when "y"
-          puts "Excelent!  Gas will handle rsa keys for this user."
-          return false
-        else
-          puts @invalid_input_response_with_default
-        end
-      end
-    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 of this user's ssh keys too!?!"  
-      puts "(github account keys can be removed as well!)"
-      puts
-      puts "a:  All, the local copy, and checks github too."
-      puts "l:  Remove local key only."
-      puts "g:  Removes key from github.com only."
-      puts "n:  Don't remove this user's keys."
-      puts "Default: l"
-
-      while true
-        delete_all_keys = clean_gets
-
-        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
-    
-    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 = clean_gets.downcase
-        case upload_key
-        when "y", ""
-          return true
-        when "n"
-          return false
-        else
-          puts @invalid_input_response_with_default
-        end
-      end
-    end
-    
-    def self.user_wants_to_overwrite_existing_rsa_key?
-      puts "~/.ssh/id_rsa already exists.  Overwrite?"
-      puts "[y/n]"
-
-      while true
-        overwrite = clean_gets
-        case overwrite
-          when "y"
-            return true
-          when "n"
-            return false
-          else
-            puts "please respond 'y' or 'n'"
-        end
-      end
-    end
-    
-    # If the user hits ctrl+c with this, it will exit cleanly
-    def self.clean_gets
-      begin
-        getit = STDIN.gets.strip
-      rescue SystemExit, Interrupt           # catch if they hit ctrl+c
-        puts
-        puts "Safely aborting operation..."    # reassure user that ctrl+c is fine to use.  
-        exit
-      end
-      
-      return getit
-    end
-
-  end
-end

data/lib/gas/settings.rb

@@ -1,28 +0,0 @@
-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