gitsu 0.0.1

data/features/support/env.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+require 'gitsu'

data/features/switch_to_fully_qualified_user.feature

@@ -0,0 +1,10 @@
+Feature: Switch to fully qualified user
+    As a new user
+    I want to switch to my Git user
+    So that I can commit code
+
+    Scenario: Switch to fully qualified user
+        Given no user is selected
+        When I type "git su 'John Galt <jg@example.com>'"
+        Then I should see "Switched local user to John Galt <jg@example.com>"
+        And user "John Galt <jg@example.com>" should be selected in "local" scope

data/features/switch_to_stored_user.feature

@@ -0,0 +1,49 @@
+Feature: Switch to stored user
+    As an user
+    I want to quickly switch to my user
+    So that I can commit code
+
+    Scenario Outline: One match found
+        Given no user is selected
+        And user list is
+        """
+        rackstraw@github.com: Raphe Rackstraw
+        """
+        When I type "git su <request>"
+        Then I should see "<output>"
+        And user "<selected_user>" should be selected in "local" scope
+
+        Scenarios: Existing user match
+            | request   | selected_user                           | output                                                          |
+            | raphe     | Raphe Rackstraw <rackstraw@github.com>  | Switched local user to Raphe Rackstraw <rackstraw@github.com>  |
+            | Raphe     | Raphe Rackstraw <rackstraw@github.com>  | Switched local user to Raphe Rackstraw <rackstraw@github.com>  |
+            | git       | Raphe Rackstraw <rackstraw@github.com>  | Switched local user to Raphe Rackstraw <rackstraw@github.com>  |
+            | rr        | Raphe Rackstraw <rackstraw@github.com>  | Switched local user to Raphe Rackstraw <rackstraw@github.com>  |
+            | RR        | Raphe Rackstraw <rackstraw@github.com>  | Switched local user to Raphe Rackstraw <rackstraw@github.com>  |
+
+    Scenario: No match found
+        Given no user is selected
+        And user list contains user "Raphe Rackstraw" with email "rrackstraw@github.com"
+        When I type "git su joe"
+        Then I should see "No user found matching 'joe'"
+        And no user should be selected
+
+    Scenario Outline: Multiple matches found
+        Given no user is selected
+        And user list is
+        """
+        jdean@github.com: James Dean
+        jack@github.com: Jacky Smith
+        jim@github.com: Jack Smythe
+        amos@github.com: Amos Arphaxad
+        molly@github.com: Molly Meldrum
+        """
+        When I type "git su <request>"
+        Then user "<selected_user>" should be selected in "local" scope
+
+        Scenarios: Existing user match
+            | request   | selected_user                           | reason                   |
+            | jack      | Jack Smythe <jim@github.com>            | exact first name match   |
+            | am        | Amos Arphaxad <amos@github.com>         | first name snippet       |
+            | me        | Molly Meldrum <molly@github.com>        | other name snippet       |
+

data/gitsu.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gitsu/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "gitsu"
+  gem.version       = GitSu::VERSION
+  gem.authors       = ["drrb"]
+  gem.email         = ["drrb@github.com"]
+  gem.description   = %q{Manage your Git users}
+  gem.summary       = %q{Gitsu allows you to quickly configure and switch between Git users}
+  gem.homepage      = "http://drrb.github.com/gitsu"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/gitsu.rb

@@ -0,0 +1,9 @@
+require 'gitsu/factory'
+require 'gitsu/git'
+require 'gitsu/gitsu'
+require 'gitsu/runner'
+require 'gitsu/shell'
+require 'gitsu/switcher'
+require 'gitsu/user_file'
+require 'gitsu/user_list'
+require 'gitsu/user'

data/lib/gitsu/factory.rb

@@ -0,0 +1,23 @@
+module GitSu
+    class Factory
+        def initialize(output)
+            @output = output
+        end
+
+        def switcher
+            user_list_file = File.expand_path("~/.gitsu")
+            shell = Shell.new
+            git = CachingGit.new(shell)
+            user_list = UserList.new(user_list_file)
+            Switcher.new(git, user_list, @output)
+        end
+
+        def git_su
+            Gitsu.new(switcher, @output)
+        end
+
+        def runner
+            Runner.new(@output)
+        end
+    end
+end

data/lib/gitsu/git.rb

@@ -0,0 +1,136 @@
+module GitSu
+    class Git
+        class InvalidConfigError < RuntimeError
+        end
+
+        class ConfigSettingError < RuntimeError
+        end
+
+        def initialize(shell)
+            @shell = shell
+        end
+
+        def config_command(scope, suffix)
+            command = "git config "
+            unless scope == :derived
+                command << "--#{scope} "
+            end 
+            command << suffix
+        end
+
+        def execute_config_command(scope, command)
+            @shell.execute config_command(scope, command)
+        end
+
+        def capture_config_command(scope, command)
+            @shell.capture config_command(scope, command)
+        end
+
+        def get_config(scope, key)
+            capture_config_command(scope, key)
+        end
+
+        def set_config(scope, key, value)
+            # replace <'> with <'\''>. E.g. O'Grady -> O'\''Grady
+            escaped_value = value.gsub(/'/, "'\\\\\''")
+            execute_config_command(scope, "#{key} '#{escaped_value}'")
+        end
+
+        def unset_config(scope, key)
+            capture_config_command(scope, "--unset #{key}")
+        end
+
+        def list_config(scope)
+            capture_config_command(scope, "--list").chomp.split("\n")
+        end
+
+        def remove_config_section(scope, section)
+            capture_config_command(scope, "--remove-section #{section} 2>/dev/null")
+        end
+
+        def get_color(color_name)
+            capture_config_command(:derived, "--get-color '' '#{color_name}'")
+        end
+
+        def select_user(user, scope)
+            set_config(scope, "user.name", user.name) or raise ConfigSettingError, "Couldn't update user config in '#{scope}' scope"
+            set_config(scope, "user.email", user.email)
+        end
+
+        def selected_user(scope)
+            name = get_config(scope, "user.name")
+            if name.empty?
+                User::NONE
+            else
+                email = get_config(scope, "user.email")
+                User.new(name, email)
+            end
+        end
+
+        def edit_gitsu_config
+            execute_config_command(:derived, "--edit --file #{File.expand_path '~/.gitsu'}")
+        end
+
+        def clear_user(scope)
+            unset_config(scope, "user.name")
+            unset_config(scope, "user.email")
+            if list_config(scope).select { |e| e =~ /^user\./ }.empty?
+                remove_config_section(scope, "user")
+            end
+        end
+
+        def color_output?
+            execute_config_command(:derived, "--get-colorbool color.ui")
+        end
+
+        def default_select_scope
+            scope_string = get_config(:derived, "git-su.defaultSelectScope")
+            if scope_string.empty?
+                :local
+            elsif scope_string =~ /^(local|global|system)$/
+                scope_string.to_sym
+            else
+                raise InvalidConfigError, "Invalid configuration value found for git-su.defaultSelectScope: '#{scope_string}'. Expected one of 'local', 'global', or 'system'."
+            end
+        end
+
+        def render(user)
+            if color_output?
+                user_color = get_color "blue"
+                email_color = get_color "green"
+                reset_color = get_color "reset"
+                user.to_ansi_s(user_color, email_color, reset_color)
+            else
+                user.to_s
+            end
+        end
+
+        def render_user(scope)
+            render selected_user(scope)
+        end
+        
+    end
+
+    class CachingGit < Git
+
+        def get_color(color_name)
+            @colors ||= {}
+            #TODO: what if it's an invalid color?
+            @colors[color_name] ||= super
+        end
+
+        def color_output?
+            @color_output.nil? ? @color_output = super : @color_output
+        end
+
+        def clear_user(scope)
+            # Git complains if you try to clear the user when the config file is missing
+            super unless selected_user(scope).none?
+        end
+
+        def selected_user(scope)
+            @selected_users ||= {}
+            @selected_users[scope] ||= super
+        end
+    end
+end

data/lib/gitsu/gitsu.rb

@@ -0,0 +1,94 @@
+require 'optparse'
+
+module GitSu
+    class Gitsu
+
+        def initialize(switcher, output)
+            @switcher, @output = switcher, output
+        end
+
+        def go(args)
+            options = {}
+            optparse = OptionParser.new do |opts|
+                opts.banner = "Usage: git-su [options] user"
+
+                opts.on('-t', '--list', 'List the configured users') do
+                    options[:list] = true
+                end
+
+                opts.on('-c', '--clear', 'Clear the current user') do
+                    options[:clear] = true
+                end
+
+                opts.on('-a', '--add USER <EMAIL>', 'Add a user in email format (e.g. John Citizen <jcitizen@example.com>)') do |user|
+                    options[:add] = user
+                end
+
+                opts.on('-e', '--edit', 'Open the Gitsu config file in an editor') do
+                    options[:edit] = true
+                end
+
+                options[:scope] = []
+                opts.on('-l', '--local', 'Change user in local scope') do
+                    options[:scope] << :local
+                end
+
+                opts.on('-g', '--global', 'Change user in global scope') do
+                    options[:scope] << :global
+                end
+
+                opts.on('-s', '--system', 'Change user in system scope') do
+                    options[:scope] << :system
+                end
+
+                opts.on('-h', '--help', 'Show this message') do
+                    options[:help] = true
+                    @output.puts opts
+                end
+            end
+
+            optparse.parse! args
+            run(options, args)
+        end
+
+        def run(options, args)
+            if options[:help]
+                return
+            end
+
+            if options[:list]
+                @switcher.list
+                return
+            end
+
+            if options[:edit]
+                @switcher.edit_config
+                return
+            end
+
+            scopes = options[:scope]
+
+            if options[:clear]
+                clear_scopes = scopes.empty? ? [:all] : scopes
+                @switcher.clear *clear_scopes
+            end
+
+            if options[:add]
+                @switcher.add options[:add]
+            end
+            
+            if args.empty?
+                unless options[:add] || options [:clear]
+                    print_scopes = scopes.empty? ? [:all] : scopes
+                    @switcher.print_current *print_scopes
+                end
+            else
+                select_scopes = scopes.empty? ? [:default] : scopes
+                select_scopes.each do |scope|
+                    @switcher.request(args.join(" "), scope)
+                end
+            end
+        end
+    end
+end
+

data/lib/gitsu/runner.rb

@@ -0,0 +1,18 @@
+module GitSu
+    class Runner
+        def initialize(output)
+            @output = output
+        end
+
+        def run
+            begin
+                yield
+            rescue Interrupt => interrupted
+                @output.puts "Interrupted"
+            rescue StandardError => error
+                @output.puts error.message
+            end
+        end
+    end
+end
+

data/lib/gitsu/shell.rb

@@ -0,0 +1,16 @@
+module GitSu
+    class Shell
+        def capture(command)
+            output = `#{command}`.strip
+            if block_given?
+                yield(output, $?)
+            else
+                output
+            end
+        end
+
+        def execute(command)
+            system command
+        end
+    end
+end

data/lib/gitsu/switcher.rb

@@ -0,0 +1,94 @@
+class Array
+    def list
+        if empty?
+            ""
+        elsif size == 1
+            last.to_s
+        else
+            "#{self[0..-2].map{|e| e.to_s}.join(", ")} and #{last.to_s}"
+        end
+    end
+
+    def pluralize(word)
+        size > 1 ? word + "s" : word
+    end
+end
+
+module GitSu
+
+    class Switcher
+        def initialize(git, user_list, output)
+            @git, @user_list, @output = git, user_list, output
+        end
+
+        def request(user, scope)
+            begin
+                matching_user = User.parse(user)
+            rescue User::ParseError => parse_error
+                matching_user = @user_list.find(user)
+            end
+
+            if matching_user.none?
+                @output.puts "No user found matching '#{user}'"
+            else
+                scope = scope == :default ? @git.default_select_scope : scope
+                @git.select_user(matching_user, scope)
+                @output.puts "Switched #{scope} user to #{@git.render matching_user}"
+            end
+        end
+        
+        def print_current(*scopes)
+            if scopes.include? :all
+                @output.puts "Current user: #{@git.render_user(:derived)}"
+                @output.puts
+                @output.puts "Local: #{@git.render_user(:local)}"
+                @output.puts "Global: #{@git.render_user(:global)}"
+                @output.puts "System: #{@git.render_user(:system)}"
+            else
+                scopes.each do |scope|
+                    unless @git.selected_user(scope).none?
+                        @output.puts @git.render_user(scope)
+                    end
+                end
+            end
+        end
+
+        def edit_config
+            @git.edit_gitsu_config
+        end
+
+        def clear(*scopes)
+            scope_list = scopes.list
+
+            if scopes.include? :all
+                scopes = [:local, :global, :system]
+            end
+
+            @output.puts "Clearing Git #{scopes.pluralize('user')} in #{scope_list} #{scopes.pluralize('scope')}"
+            scopes.each do |scope|
+                @git.clear_user(scope)
+            end
+        end
+
+        def list
+            @user_list.list.each do |user|
+                @output.puts @git.render(user)
+            end
+        end
+
+        def add(user_string)
+            begin
+                user = User.parse(user_string)
+            rescue User::ParseError => parse_error
+                @output.puts parse_error.message
+                return
+            end
+            if @user_list.list.include? user
+                @output.puts "User '#{user}' already in user list"
+            else
+                @user_list.add user
+                @output.puts "User '#{user}' added to users"
+            end
+        end
+    end
+end