git-duet 0.3.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0e935ea43b312f7b8f22a51c37ff101c8bcfa92
+  data.tar.gz: 5a01b500d7ed09135fd5f5acbd7500084ac72fe9
+SHA512:
+  metadata.gz: 92aa13d5ad13ea7540e47ba48aec5b9ae2e70aed2457dca8a0746d20fe4c1df2ee8cb3468a099e9026f1a858af9d5459faac31dffa0d3135cc4d9d802db4211f
+  data.tar.gz: 6d2e39230cf987832d19f259140cacb4b8b5663e4b0db208a0cac4a16001906190207541fa5313ef3615955836224d9351663fe74acadada7b62af85a17102c1

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 /coverage/
 /tags
+.idea/

data/.rubocop.yml

@@ -1,3 +1,9 @@
 ---
 Documentation:
   Enabled: false
+
+FileName:
+  Enabled: false
+
+DoubleNegation:
+  Enabled: false

data/.ruby-version

@@ -1 +1 @@
-2.1.0
+2.1.1

data/Gemfile

@@ -3,4 +3,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'codeclimate-test-reporter', group: :test, require: nil
+unless RUBY_PLATFORM == 'java'
+  gem 'codeclimate-test-reporter', group: :test, require: nil
+end

data/README.md

@@ -64,11 +64,12 @@ Set the author and committer via `git duet`:
 git duet jd fb
 ~~~~~
 
-When you're ready to commit, use `git duet-commit` (or add an alias like
-a normal person.  Something like `dci = duet-commit` should work.)
+When you're ready to commit, use `git duet-commit` or `git dci`
 
 ~~~~~ bash
 git duet-commit -v [any other git options]
+# or...
+git dci -v [any other git options]
 ~~~~~
 
 When you're done pairing, set the author back to yourself with `git solo`:

data/bin/git-dci

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# vim:fileencoding=utf-8
+require 'git-duet'
+exit Git::Duet::Cli.run($PROGRAM_NAME, ARGV)

data/git-duet.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rubocop'
 
+  gem.add_development_dependency 'posix-spawn' unless RUBY_PLATFORM == 'java'
   gem.add_development_dependency 'pry' unless RUBY_PLATFORM == 'java'
   gem.add_development_dependency 'simplecov' unless RUBY_PLATFORM == 'java'
 end

data/lib/git/duet/author_mapper.rb

@@ -3,79 +3,85 @@ require 'yaml'
 require 'erb'
 require 'git/duet'
 
-class Git::Duet::AuthorMapper
-  attr_accessor :authors_file
+module Git
+  module Duet
+    class AuthorMapper
+      attr_accessor :authors_file
 
-  def initialize(authors_file = nil, email_lookup = nil)
-    @authors_file = authors_file ||
-                    ENV['GIT_DUET_AUTHORS_FILE'] ||
-                    File.join(ENV['HOME'], '.git-authors')
-    @email_lookup = email_lookup ||
-                    ENV['GIT_DUET_EMAIL_LOOKUP_COMMAND']
-  end
+      def initialize(authors_file = nil, email_lookup = nil)
+        @authors_file = authors_file ||
+          ENV['GIT_DUET_AUTHORS_FILE'] ||
+          File.join(ENV['HOME'], '.git-authors')
+        @email_lookup = email_lookup ||
+          ENV['GIT_DUET_EMAIL_LOOKUP_COMMAND']
+      end
 
-  def map(*initials_list)
-    author_map = {}
-    initials_list.each do |initials|
-      author_map[initials] = author_info(initials)
-    end
-    author_map
-  end
+      def map(*initials_list)
+        author_map = {}
+        initials_list.each do |initials|
+          author_map[initials] = author_info(initials)
+        end
+        author_map
+      end
 
-  private
+      private
 
-  def author_info(initials)
-    author, username = author_map.fetch(initials).split(/;/).map(&:strip)
-    {
-      name: author,
-      email: lookup_author_email(initials, author, username)
-    }
-  end
+      def author_info(initials)
+        author, username = author_map.fetch(initials).split(/;/).map(&:strip)
+        {
+          name: author,
+          email: lookup_author_email(initials, author, username)
+        }
+      end
 
-  def lookup_author_email(initials, author, username)
-    author_email = email_from_lookup(initials, author, username)
-    return author_email unless author_email.empty?
-    return email_addresses[initials] if email_addresses[initials]
-    return email_from_template(initials, author, username) if email_template
-    return "#{username}@#{email_domain}" if username
+      def lookup_author_email(initials, author, username)
+        author_email = email_from_lookup(initials, author, username)
+        return author_email unless author_email.empty?
+        return email_addresses[initials] if email_addresses[initials]
+        if email_template
+          return email_from_template(initials, author, username)
+        end
+        return "#{username}@#{email_domain}" if username
 
-    author_name_parts = author.split
-    "#{author_name_parts.first[0, 1].downcase}." <<
-      "#{author_name_parts.last.downcase}@#{email_domain}"
-  end
+        author_name_parts = author.split
+        "#{author_name_parts.first[0, 1].downcase}." \
+        "#{author_name_parts.last.downcase}@#{email_domain}"
+      end
 
-  def email_from_lookup(initials, author, username)
-    return '' unless @email_lookup
-    `#{@email_lookup} '#{initials}' '#{author}' '#{username}'`.strip
-  end
+      def email_from_lookup(initials, author, username)
+        return '' unless @email_lookup
+        `#{@email_lookup} '#{initials}' '#{author}' '#{username}'`.strip
+      end
 
-  def email_from_template(initials, author, username)
-    return ERB.new(email_template).result(binding)
-  rescue StandardError => e
-    $stderr.puts("git-duet: email template rendering error: #{e.message}")
-    raise Git::Duet::ScriptDieError, 8
-  end
+      def email_from_template(initials, author, username)
+        return ERB.new(email_template).result(binding)
+      rescue StandardError => e
+        $stderr.puts("git-duet: email template rendering error: #{e.message}")
+        raise Git::Duet::ScriptDieError, 8
+      end
 
-  def author_map
-    @author_map ||= (cfg['authors'] || cfg['pairs'])
-  end
+      def author_map
+        @author_map ||= (cfg['authors'] || cfg['pairs'])
+      end
 
-  def email_addresses
-    @email_addresses ||= (cfg['email_addresses'] || {})
-  end
+      def email_addresses
+        @email_addresses ||= (cfg['email_addresses'] || {})
+      end
 
-  def email_domain
-    @email_domain ||= cfg.fetch('email').fetch('domain')
-  end
+      def email_domain
+        @email_domain ||= cfg.fetch('email').fetch('domain')
+      end
 
-  def email_template
-    @email_template || cfg['email_template']
-  end
+      def email_template
+        @email_template || cfg['email_template']
+      end
 
-  def cfg
-    @cfg ||= YAML.load(IO.read(authors_file))
-  rescue StandardError => e
-    $stderr.puts("git-duet: Missing or corrupt authors file: #{e.message}")
-    raise Git::Duet::ScriptDieError, 3
+      def cfg
+        @cfg ||= YAML.load(IO.read(authors_file))
+      rescue StandardError => e
+        $stderr.puts("git-duet: Missing or corrupt authors file: #{e.message}")
+        raise Git::Duet::ScriptDieError, 3
+      end
+    end
   end
 end

data/lib/git/duet/cli.rb

@@ -3,115 +3,121 @@ require 'optparse'
 require 'git/duet'
 require 'git/duet/script_die_error'
 
-class Git::Duet::Cli
-  class << self
-    def run(prog, argv)
-      method_name = File.basename(prog)
-        .sub(/^git-duet-/, '').sub(/^git-/, '').tr('-', '_')
-      send(method_name, parse_options(method_name, argv.clone))
-      0
-    rescue NoMethodError
-      raise ScriptError, 'How did you get here???'
-    rescue Git::Duet::ScriptDieError => e
-      e.exit_code
-    end
+module Git
+  module Duet
+    class Cli
+      class << self
+        def run(prog, argv)
+          method_name = File.basename(prog)
+          .sub(/^git-duet-/, '').sub(/^git-/, '').tr('-', '_')
+          send(method_name, parse_options(method_name, argv.clone))
+          0
+        rescue NoMethodError
+          raise ScriptError, 'How did you get here???'
+        rescue Git::Duet::ScriptDieError => e
+          e.exit_code
+        end
 
-    private
+        private
 
-    def parse_options(method_name, argv)
-      case method_name
-      when 'pre_commit', 'install_hook'
-        parse_generic_options(argv)
-      else
-        send("parse_#{method_name}_options", argv)
-      end
-    end
+        def parse_options(method_name, argv)
+          case method_name
+          when 'pre_commit', 'install_hook'
+            parse_generic_options(argv)
+          else
+            send("parse_#{method_name}_options", argv)
+          end
+        end
 
-    def with_common_opts(argv, banner)
-      options = {}
-      leftover_argv = OptionParser.new do |opts|
-        opts.banner = banner.gsub(/__PROG__/, opts.program_name)
-        opts.on('-q', 'Silence output') do |q|
-          options[:quiet] = true
+        def with_common_opts(argv, banner)
+          options = {}
+          leftover_argv = OptionParser.new do |opts|
+            opts.banner = banner.gsub(/__PROG__/, opts.program_name)
+            opts.on('-q', 'Silence output') do |q|
+              options[:quiet] = true
+            end
+            yield opts, options if block_given?
+          end.parse!(argv)
+          [leftover_argv, options]
         end
-        yield opts, options if block_given?
-      end.parse!(argv)
-      [leftover_argv, options]
-    end
 
-    def parse_solo_options(argv)
-      parse_options_with_positional_args(
-        argv, '<soloist-initials>') do |leftover_argv, options|
-        options[:soloist] = leftover_argv.first
-      end
-    end
+        def parse_solo_options(argv)
+          parse_options_with_positional_args(
+            argv, '<soloist-initials>') do |leftover_argv, options|
+              options[:soloist] = leftover_argv.first
+            end
+        end
 
-    def parse_duet_options(argv)
-      parse_options_with_positional_args(
-        argv, '<alpha-initials> <omega-initials>') do |leftover_argv, options|
-        options[:alpha], options[:omega] = leftover_argv[0..1]
-      end
-    end
+        def parse_duet_options(argv)
+          parse_options_with_positional_args(
+            argv,
+            '<alpha-initials> <omega-initials>'
+          ) do |leftover_argv, options|
+            options[:alpha], options[:omega] = leftover_argv[0..1]
+          end
+        end
 
-    def parse_options_with_positional_args(argv, usage)
-      leftover_argv, options = with_common_opts(
-        argv, 'Usage: __PROG__ [options] ' << usage
-      ) do |opts, options_hash|
-        opts.on('-g', '--global', 'Change global git config') do |g|
-          options_hash[:global] = true
+        def parse_options_with_positional_args(argv, usage)
+          leftover_argv, options = with_common_opts(
+            argv, 'Usage: __PROG__ [options] ' << usage
+          ) do |opts, options_hash|
+            opts.on('-g', '--global', 'Change global git config') do |g|
+              options_hash[:global] = true
+            end
+          end
+          yield leftover_argv, options
+          options
         end
-      end
-      yield leftover_argv, options
-      options
-    end
 
-    def parse_generic_options(argv)
-      with_common_opts(argv, 'Usage: __PROG__').last
-    end
+        def parse_generic_options(argv)
+          with_common_opts(argv, 'Usage: __PROG__').last
+        end
 
-    def parse_commit_options(argv)
-      opts_argv = []
-      opts_argv << '-q' if argv.delete('-q')
-      options = with_common_opts(opts_argv, 'Usage: __PROG__').last
-      options[:passthrough_args] = argv
-      options
-    end
+        def parse_commit_options(argv)
+          opts_argv = []
+          opts_argv << '-q' if argv.delete('-q')
+          options = with_common_opts(opts_argv, 'Usage: __PROG__').last
+          options[:passthrough_args] = argv
+          options
+        end
 
-    def solo(options)
-      require 'git/duet/solo_command'
-      Git::Duet::SoloCommand.new(
-        options.fetch(:soloist),
-        options[:quiet],
-        options[:global]
-      ).execute!
-    end
+        def solo(options)
+          require 'git/duet/solo_command'
+          Git::Duet::SoloCommand.new(
+            options.fetch(:soloist),
+            options[:quiet],
+            options[:global]
+          ).execute!
+        end
 
-    def duet(options)
-      require 'git/duet/duet_command'
-      Git::Duet::DuetCommand.new(
-        options.fetch(:alpha),
-        options.fetch(:omega),
-        options[:quiet],
-        options[:global]
-      ).execute!
-    end
+        def duet(options)
+          require 'git/duet/duet_command'
+          Git::Duet::DuetCommand.new(
+            options.fetch(:alpha),
+            options.fetch(:omega),
+            options[:quiet],
+            options[:global]
+          ).execute!
+        end
 
-    def pre_commit(options)
-      require 'git/duet/pre_commit_command'
-      Git::Duet::PreCommitCommand.new(options[:quiet]).execute!
-    end
+        def pre_commit(options)
+          require 'git/duet/pre_commit_command'
+          Git::Duet::PreCommitCommand.new(options[:quiet]).execute!
+        end
 
-    def install_hook(options)
-      require 'git/duet/install_hook_command'
-      Git::Duet::InstallHookCommand.new(options[:quiet]).execute!
-    end
+        def install_hook(options)
+          require 'git/duet/install_hook_command'
+          Git::Duet::InstallHookCommand.new(options[:quiet]).execute!
+        end
 
-    def commit(options)
-      require 'git/duet/commit_command'
-      Git::Duet::CommitCommand.new(
-        options[:passthrough_args],
-        options[:quiet]
-      ).execute!
+        def commit(options)
+          require 'git/duet/commit_command'
+          Git::Duet::CommitCommand.new(
+            options[:passthrough_args],
+            options[:quiet]
+          ).execute!
+        end
+      end
     end
   end
 end

data/lib/git/duet/command_methods.rb

@@ -3,132 +3,138 @@ require 'English'
 require 'git/duet'
 require 'git/duet/script_die_error'
 
-module Git::Duet::CommandMethods
-  private
-
-  def report_env_vars
-    var_map.each do |key, value|
-      info("#{key}='#{value}'")
-    end
-  end
-
-  def write_env_vars
-    in_repo_root do
-      var_map.each do |key, value|
-        exec_check(
-          "#{git_config} #{Git::Duet::Config.namespace}." <<
-            "#{key.downcase.gsub(/_/, '-')} '#{value}'"
-        )
+module Git
+  module Duet
+    module CommandMethods
+      private
+
+      def report_env_vars
+        var_map.each do |key, value|
+          info("#{key}='#{value}'")
+        end
       end
-      exec_check("#{git_config} #{Git::Duet::Config
+
+      def write_env_vars
+        in_repo_root do
+          var_map.each do |key, value|
+            exec_check(
+              "#{git_config} #{Git::Duet::Config.namespace}." \
+              "#{key.downcase.gsub(/_/, '-')} '#{value}'"
+            )
+          end
+          exec_check("#{git_config} #{Git::Duet::Config
                                   .namespace}.mtime #{Time.now.to_i}")
-    end
-  end
+        end
+      end
 
-  def git_config
-    "git config#{@global ? ' --global' : ''}"
-  end
+      def git_config
+        "git config#{@global ? ' --global' : ''}"
+      end
 
-  def author_env_vars_set?
-    %x(#{author_name_command} && #{author_email_command})
-    $CHILD_STATUS == 0
-  end
+      def author_env_vars_set?
+        %x(#{author_name_command} && #{author_email_command})
+        $CHILD_STATUS == 0
+      end
 
-  def author_name_command
-    "git config --get #{Git::Duet::Config.namespace}.git-author-name"
-  end
+      def author_name_command
+        "git config --get #{Git::Duet::Config.namespace}.git-author-name"
+      end
 
-  def author_email_command
-    "git config --get #{Git::Duet::Config.namespace}.git-author-email"
-  end
+      def author_email_command
+        "git config --get #{Git::Duet::Config.namespace}.git-author-email"
+      end
 
-  def current_config_command
-    "git config --get-regexp #{Git::Duet::Config.namespace}"
-  end
+      def current_config_command
+        "git config --get-regexp #{Git::Duet::Config.namespace}"
+      end
 
-  def show_current_config
-    info(exec_check(current_config_command))
-  end
+      def show_current_config
+        info(exec_check(current_config_command))
+      end
 
-  def dump_env_vars
-    extract_env_vars_from_git_config.each do |k, v|
-      puts "#{k}='#{v}'"
-    end
-  end
+      def dump_env_vars
+        extract_env_vars_from_git_config.each do |k, v|
+          puts "#{k}='#{v}'"
+        end
+      end
 
-  def extract_env_vars_from_git_config
-    dest = {}
-    env_vars.each do |env_var, config_key|
-      begin
-        value = check_env_var_config_key(config_key)
-        dest[env_var] = value unless value.empty?
-      rescue StandardError => e
-        error("#{e.message}")
+      def extract_env_vars_from_git_config
+        dest = {}
+        env_vars.each do |env_var, config_key|
+          begin
+            value = check_env_var_config_key(config_key)
+            dest[env_var] = value unless value.empty?
+          rescue StandardError => e
+            error("#{e.message}")
+          end
+        end
+        dest
       end
-    end
-    dest
-  end
 
-  def check_env_var_config_key(config_key)
-    exec_check("git config #{Git::Duet::Config.namespace}.#{config_key}").chomp
-  end
+      def check_env_var_config_key(config_key)
+        exec_check(
+          "git config #{Git::Duet::Config.namespace}.#{config_key}"
+        ).chomp
+      end
 
-  def exec_git_commit
-    if author_env_vars_set?
-      exec 'git commit ' << signoff_arg << quoted_passthrough_args
-    else
-      fail Git::Duet::ScriptDieError, 17
-    end
-  end
+      def exec_git_commit
+        if author_env_vars_set?
+          exec 'git commit ' << signoff_arg << quoted_passthrough_args
+        else
+          fail Git::Duet::ScriptDieError, 17
+        end
+      end
 
-  def in_repo_root
-    Dir.chdir(exec_check('git rev-parse --show-toplevel').chomp) do
-      yield
-    end
-  end
+      def in_repo_root
+        Dir.chdir(exec_check('git rev-parse --show-toplevel').chomp) do
+          yield
+        end
+      end
 
-  def exec_check(command, okay_statuses = [0].freeze)
-    output = `#{command}`
-    unless okay_statuses.include?($CHILD_STATUS.exitstatus)
-      error("Command #{command.inspect} exited with #{$CHILD_STATUS.to_i}")
-      fail Git::Duet::ScriptDieError, 1
-    end
-    output
-  end
+      def exec_check(command, okay_statuses = [0].freeze)
+        output = `#{command}`
+        unless okay_statuses.include?($CHILD_STATUS.exitstatus)
+          error("Command #{command.inspect} exited with #{$CHILD_STATUS.to_i}")
+          fail Git::Duet::ScriptDieError, 1
+        end
+        output
+      end
 
-  def with_output_unquieted(&block)
-    @old_quiet = @quiet
-    @quiet = false
-    block.call
-    @quiet = @old_quiet
-  rescue StandardError => e
-    @quiet = @old_quiet
-    raise e
-  end
+      def with_output_unquieted(&block)
+        @old_quiet = @quiet
+        @quiet = false
+        block.call
+        @quiet = @old_quiet
+      rescue StandardError => e
+        @quiet = @old_quiet
+        raise e
+      end
 
-  def with_output_quieted(&block)
-    @old_quiet = @quiet
-    @quiet = true
-    block.call
-  rescue StandardError => e
-    raise e
-  ensure
-    @quiet = @old_quiet
-  end
+      def with_output_quieted(&block)
+        @old_quiet = @quiet
+        @quiet = true
+        block.call
+      rescue StandardError => e
+        raise e
+      ensure
+        @quiet = @old_quiet
+      end
 
-  def info(msg)
-    $stdout.puts(msg) unless quiet?
-  end
+      def info(msg)
+        $stdout.puts(msg) unless quiet?
+      end
 
-  def error(msg)
-    $stderr.puts(msg) unless quiet?
-  end
+      def error(msg)
+        $stderr.puts(msg) unless quiet?
+      end
 
-  def prompt
-    $stdout.print '> '
-  end
+      def prompt
+        $stdout.print '> '
+      end
 
-  def quiet?
-    ENV['GIT_DUET_QUIET'] == '1' || @quiet
+      def quiet?
+        ENV['GIT_DUET_QUIET'] == '1' || @quiet
+      end
+    end
   end
 end