simple_gas 0.1.9

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Fredrik Wallgren
+
+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.textile

@@ -0,0 +1,53 @@
+h1. gas - manage your git author accounts
+
+"!http://travis-ci.org/walle/gas.png!":http://travis-ci.org/walle/gas
+
+h2. Description
+
+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
+
+The best way to install gas is with RubyGems:
+
+bc. $ [sudo] gem install gas
+
+You can install from source:
+
+bc. $ cd gas/
+$ bundle
+$ rake install
+
+h2. Running
+
+The default task is to list authors
+
+bc. $ gas
+
+bc. $ gas list
+
+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 an author use, add
+
+bc. $ gas add walle "Fredrik Wallgren" fredrik.wallgren@gmail.com
+
+And the main usage, use
+
+bc. $ gas use walle
+
+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

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'gas'
+
+class GasRunner < Thor
+
+  default_task :list
+
+  desc "list", "Lists your authors"
+  def list
+    Gas.list
+  end
+
+  desc "show", "Shows your current user"
+  def show
+    Gas.show
+  end
+
+  desc "use AUTHOR", "Uses author"
+  def use(nickname)
+    Gas.use nickname
+  end
+
+  desc "add NICKNAME NAME EMAIL", "Adds author to gasconfig"
+  def add(nickname, name, email)
+    Gas.add nickname, name, email
+  end
+
+  desc "import NICKNAME", "Imports current user to gasconfig"
+  def import(nickname)
+    Gas.import nickname
+  end
+
+  desc "delete AUTHOR", "Deletes author"
+  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
+    Gas.version
+  end
+  map %w(-v --version) => :version
+
+end
+
+GasRunner.start

data/lib/gas/config.rb

@@ -0,0 +1,123 @@
+require 'fileutils'
+
+module Gas
+
+  # Class that keeps track of users
+  class Config
+    attr_reader :users
+
+    # 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 = "#{GAS_DIRECTORY}/gas.authors"
+      @gas_dir = GAS_DIRECTORY
+      @config = ''
+
+      if config.nil?
+        if !File.exists? @config_file
+          Dir::mkdir(@gas_dir)
+          FileUtils.touch @config_file
+        end
+
+        @config = File.read(@config_file)
+      else
+        @config = config
+      end
+
+      if users.nil?
+        @users = []
+        @config.scan(/\[(.+)\]\s+name = (.+)\s+email = (.+)/) do |nickname, name, email|
+          @users << User.new(name, email, nickname)
+        end
+      else
+        @users = users
+      end
+    end
+
+    # Checks if a user with _nickname_ exists
+    # @param [String] nickname
+    # @return [Boolean]
+    def exists?(nickname)
+      @users.each do |user|
+        if user.nickname == nickname
+          return true;
+        end
+      end
+
+      false
+    end
+
+    # Returns the user with nickname nil if no such user exists
+    # @param [String|Symbol] nickname
+    # @return [User|nil]
+    def get(nickname)
+      @users.each do |user|
+        if user.nickname == nickname.to_s
+          return user
+        end
+      end
+
+      nil
+    end
+
+    # Override [] to get hash style acces to users
+    # @param [String|Symbol] nickname
+    # @return [User|nil]
+    def [](nickname)
+      get nickname
+    end
+
+    # Adds a user
+    # @param [User]
+    def add(user)
+      @users << user
+    end
+
+    # Deletes a user by nickname
+    # @param [String] nickname The nickname of the user to delete
+    def delete(nickname)
+      @users.delete_if do |user|
+        user.nickname == nickname
+      end
+    end
+
+    # Saves the current users to the config file
+    def save!
+      File.open @config_file, 'w' do |file|
+        file.write self
+      end
+    end
+
+
+    # Override to_s to output correct format
+    def to_s
+      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
+end

data/lib/gas/gitconfig.rb

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

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

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