git-duet 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c0d1aba2d97cec79a441df782543cd66f943074
-  data.tar.gz: bde7359043a472e8971bb22c8310d60e94b99687
+  metadata.gz: 50d7af1c799d72430af337f3ebce7f5594628022
+  data.tar.gz: 8efc2502e7dbcf5048c208dc38dffef004b10ae8
 SHA512:
-  metadata.gz: 60244f94949de3e18600cb59358128ccea448e87f96468fd4a3677d0e2cc42ce4add71309f7a008ef4b523da340fa95ca662f6ad8ee4a36f4291aa267ce67aa3
-  data.tar.gz: ff54e2644dcf6d61c00a382ddc99c821ef7c15b1a8d419da3e02879b5bbc47a36dc1bf0a063af30fa305a9fe26681e538e6f5c1d6a44168224a173842b5a7a52
+  metadata.gz: e36a169a110dbef6344c8f4c58dce163c4e83c432be772136a07095f84ba2ba80037da6bf2f8ba016c9211e92d23341ccae7209c502dc808aa3fd6063e0a1862
+  data.tar.gz: c579fc838fe6616f768cf28a25e29a6d7e6c9a56ef050dc56f20d014305e4af3f289062718b0b7d8d3247337d5bf7bc73574cf8a70105d25b6ea372add205c85

data/.rubocop.yml

@@ -1,4 +1,9 @@
 ---
+AllCops:
+  Include:
+    - git-duet.gemspec
+    - Rakefile
+    - Gemfile
 Documentation:
   Enabled: false
 

data/.ruby-version

@@ -1 +1 @@
-2.1.1
+2.1.3

data/.travis.yml

@@ -1,3 +1,4 @@
+---
 language: ruby
 env:
   global:
@@ -8,25 +9,18 @@ matrix:
 rvm:
 - 1.9.3
 - 2.0.0
-- 2.1.0
+- 2.1.3
 - jruby-19mode
 before_script:
-- git clone https://github.com/sstephenson/bats.git
-- cd bats && sudo ./install.sh /usr/local
+- "git clone https://github.com/sstephenson/bats.git"
+- "cd bats && sudo ./install.sh /usr/local"
 script:
 - bundle exec rake
-- bats test
+- bundle exec bats test
 notifications:
-  email: github+git-duet@modcloth.com
-deploy:
-  provider: rubygems
-  api_key:
-    secure: aW7HYNkTGp3N8awbuJtDfko1CXBDTzElggAOQsA4p//V06Q/qH7ZTNZxPTf5/bPlmjDRgttMVv+zm3YGgb4pFdHzSWI+McLf+eI6g2I8s/Sp/GZQ2+dxH1wBqPtMhSI/Rv7R+J6GznALjKhM/PnNpPl6gsWePFbMebhKgKUvcHo=
-  gem: git-duet
-  on:
-    tags: true
-    repo: modcloth/git-duet
-addons:
-  code_climate:
-    repo_token:
-      secure: A/K+dw6//V8WkB4PapKa1BqEGbwxWbhvHSCFKe+CnHSJ19vDbij2C1x8uzh3NpYTI+B9a5/p9r0B8AmVFI2hKU5CIdGiqMd+sEMM/OzSBeMTIO8d0NKJRfJEGH9yRSlka3cpwLMKmbdPorYnI0iKdVvWLabPhzneK8qYCgHMSWw=
+  email:
+    recipients:
+    - dan@meatballhat.com
+    - jesse.szwedko@gmail.com
+    - rafael.colton@gmail.com
+    - sheenathejunglegirl@gmail.com

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 ModCloth, Inc.
+Copyright (c) 2014 Dan Buch & contributors
 
 MIT License
 

data/README.md

@@ -1,10 +1,10 @@
 # Git Duet
 
 [![Gem Version](https://badge.fury.io/rb/git-duet.png)](http://badge.fury.io/rb/git-duet)
-[![Build Status](https://travis-ci.org/modcloth/git-duet.png?branch=master)](https://travis-ci.org/modcloth/git-duet)
+[![Build Status](https://travis-ci.org/meatballhat/git-duet.png?branch=master)](https://travis-ci.org/meatballhat/git-duet)
 [![Code Climate](https://codeclimate.com/repos/52b6ea7089af7e2ddc0b1f3c/badges/cc96e2278280922e2a3f/gpa.png)](https://codeclimate.com/repos/52b6ea7089af7e2ddc0b1f3c/feed)
 [![Dependency
-Status](https://gemnasium.com/modcloth/git-duet.png)](https://gemnasium.com/modcloth/git-duet)
+Status](https://gemnasium.com/meatballhat/git-duet.png)](https://gemnasium.com/meatballhat/git-duet)
 
 Pair harmoniously!  Working in a pair doesn't mean you've both lost your
 identity.  Git Duet helps with blaming/praising by using stuff that's
@@ -15,9 +15,9 @@ identities.
 
 Install it with `gem`:
 
-~~~~~ bash
+``` bash
 gem install git-duet
-~~~~~
+```
 
 ## Usage
 
@@ -27,55 +27,57 @@ Make an authors file with email domain, or if you're already using
 [git pair](https://github.com/pivotal/git_scripts), just symlink your
 `~/.pairs` file over to `~/.git-authors`.
 
-~~~~~ yaml
+``` yaml
 authors:
   jd: Jane Doe; jane
   fb: Frances Bar
 email:
   domain: awesometown.local
-~~~~~
+```
 
 `git duet` will use the `git pair` YAML structure if it has to (the
 difference is the top-level key being `pairs` instead of `authors`,) e.g.:
 
-~~~~~ yaml
+``` yaml
 pairs:
   jd: Jane Doe; jane
   fb: Frances Bar
 email:
   domain: awesometown.local
-~~~~~
+```
 
 If you want your authors file to live somwhere else, just tell
 Git Duet about it via the `GIT_DUET_AUTHORS_FILE` environmental
 variable, e.g.:
 
-~~~~~ bash
+``` bash
 export GIT_DUET_AUTHORS_FILE=$HOME/.secret-squirrel/git-authors
 # ...
 git duet jd am
-~~~~~
+```
 
 ### Workflow stuff
 
 Set the author and committer via `git duet`:
 
-~~~~~ bash
+``` bash
 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.)
 
-~~~~~ bash
+``` 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`:
 
-~~~~~ bash
+``` bash
 git solo jd
-~~~~~
+```
 
 ### Global Config Support
 
@@ -83,13 +85,13 @@ If you're jumping between projects and don't want to think about
 managing them all individually, you can operate on the global git
 config:
 
-~~~~~ bash
+``` bash
 git solo -g jd
-~~~~~
+```
 
-~~~~~ bash
+``` bash
 git duet --global jd fb
-~~~~~
+```
 
 ### Email Configuration
 
@@ -97,30 +99,30 @@ By default, email addresses are constructed from the first initial and
 last name ( *or* optional username after a `;`) plus email domain, e.g.
 with the following authors file:
 
-~~~~~ yaml
+``` yaml
 pairs:
   jd: Jane Doe; jane
   fb: Frances Bar
 email:
   domain: eternalstench.bog.local
-~~~~~
+```
 
 After invoking:
 
-~~~~~ bash
+``` bash
 git duet jd fb
-~~~~~
+```
 
 Then the configured email addresses will show up like this:
 
-~~~~~ bash
+``` bash
 git config user.email
 # -> jane@eternalstench.bog.local
 git config duet.env.git-author-email
 # -> jane@eternalstench.bog.local
 git config duet.env.git-committer-email
 # -> f.bar@eternalstench.bog.local
-~~~~~
+```
 
 A custom email template may be provided via the `email_template` config
 variable.  The template should be a valid ERB string and the variables
@@ -128,35 +130,35 @@ available are `author` which is the full first and last name value
 associated with each set of initials, `initials` which are the initials
 key, and `username` which is the part following `;` in the author value.
 
-~~~~~ yaml
+``` yaml
 pairs:
   jd: Jane Doe
   fb: Frances Bar
 email_template: '<%= "#{author.gsub(/ /, "-").downcase}@hamster.local" =%>'
-~~~~~
+```
 
 After invoking:
 
-~~~~~ bash
+``` bash
 git duet jd fb
-~~~~~
+```
 
 Then the configured email addresses will show up like this:
 
-~~~~~ bash
+``` bash
 git config user.email
 # -> jane-doe@hamster.local
 git config duet.env.git-author-email
 # -> jane-doe@hamster.local
 git config duet.env.git-committer-email
 # -> frances-bar@hamster.local
-~~~~~
+```
 
 If there are any exceptions to either the default format or a provided
 `email_template` config var, explicitly setting email addresses by
 initials is supported.
 
-~~~~~ yaml
+``` yaml
 pairs:
   jd: Jane Doe; jane
   fb: Frances Bar
@@ -164,35 +166,35 @@ email:
   domain: awesometown.local
 email_addresses:
   jd: jane@awesome.local
-~~~~~
+```
 
 Then Jane Doe's email will show up like this:
 
-~~~~~ bash
+``` bash
 git solo jd
 # ...
 git config user.email
 # -> jane@awesome.local
-~~~~~
+```
 
 Alternatively, if you have some other preferred way to look up email
 addresses by initials, name or username, just use that instead:
 
-~~~~~ bash
+``` bash
 export GIT_DUET_EMAIL_LOOKUP_COMMAND="$HOME/bin/custom-ldap-thingy"
 # ... do work
 git duet jd fb
 # ... observe emails being set via the specified executable
-~~~~~
+```
 
 The initials, name, and username will be passed as arguments to the
 lookup executable.  Anything written to standard output will be used as
 the email address:
 
-~~~~~ bash
+``` bash
 $HOME/bin/custom-ldap-thingy 'jd' 'Jane Doe' 'jane'
 # -> doej@behemoth.company.local
-~~~~~
+```
 
 If nothing is returned on standard output, email construction falls back
 to the decisions described above.
@@ -221,10 +223,10 @@ initials, use `git duet-pre-commit` in your pre-commit hook:
 
 *(in $REPO_ROOT/.git/hooks/pre-commit)*
 
-~~~~~ bash
+``` bash
 #!/bin/bash
 exec git duet-pre-commit
-~~~~~
+```
 
 The `duet-pre-commit` command will exit with a non-zero status if the
 cached author and committer settings are missing or stale.  The default
@@ -232,23 +234,42 @@ staleness cutoff is [20 minutes](http://en.wikipedia.org/wiki/Pomodoro_Technique
 but may be configured via the `GIT_DUET_SECONDS_AGO_STALE` environmental variable,
 which should be an integer of seconds, e.g.:
 
-~~~~~ bash
+``` bash
 export GIT_DUET_SECONDS_AGO_STALE=60
 # ... do work for more than a minute
 git commit -v
 # ... pre-commit hook fires
-~~~~~
+```
 
 If you want to use the default hook (as shown above), install it while
 in your repo like so:
 
-~~~~~ bash
+``` bash
 git duet-install-hook
-~~~~~
+```
 
 Don't worry if you forgot you already had a `pre-commit` hook installed.
 The `git duet-install-hook` command will refuse to overwrite it.
 
+### RubyMine integration
+
+In order to have the author and committer properly set when committing
+via RubyMine, a git wrapper executable may be used to override any
+executions of `git commit`.  Such an executable is available in the Git
+Duet repository, and may be installed somewhere in your `$PATH` like so:
+
+``` bash
+\curl -Ls -o ~/bin/rubymine-git-wrapper https://raw.github.com/meatballhat/git-duet/master/bin/rubymine-git-wrapper
+chmod +x ~/bin/rubymine-git-wrapper
+```
+
+Given an install location of `~/bin/rubymine-git-wrapper` as shown
+above, you would then update your RubyMine setting in
+*Preferences* =&gt; *Version Control* =&gt; *Git* to set
+**Path to Git executable** to the full path of
+ `~/bin/rubymine-git-wrapper` (with the `~` expanded).
+See issue #8 for more details.
+
 ## Compatibility
 
 Git Duet has been tested on a bunch of platform/interpreter combinations
@@ -258,8 +279,8 @@ While JRuby works it is not recommended as the VM startup time is
 usually longer than it takes most Git Duet commands to execute.
 
 If you experience badness, please [let us know via
-email](mailto:github@modcloth.com) or pretty please [create an issue on
-github](https://github.com/modcloth/git-duet/issues/new).
+email](mailto:dan@meatballhat.com) or pretty please [create an issue on
+github](https://github.com/meatballhat/git-duet/issues/new).
 
 ## Contributing
 

data/Rakefile

@@ -3,11 +3,9 @@
 require 'bundler/gem_tasks'
 
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
-desc 'Run rubocop'
-task :rubocop do
-  sh('rubocop --format simple') { |r, _| r || abort }
-end
+RuboCop::RakeTask.new
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = '--format documentation'

data/bin/rubymine-git-wrapper

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+if [[ "$1" == commit ]] ; then
+  shift
+  exec git duet-commit "$@"
+fi
+
+exec git "$@"

data/git-duet.gemspec

@@ -9,25 +9,27 @@ Gem::Specification.new do |gem|
     'Sheena McCoy'
   ]
   gem.email = %w(
-    d.buch@modcloth.com
-    j.szwedko@modcloth.com
-    r.colton@modcloth.com
-    sp.mccoy@modcloth.com
+    dan@meatballhat.com
+    jesse.szwedko@gmail.com
+    rafael.colton@gmail.com
+    sheenathejunglegirl@gmail.com
   )
-  gem.description = %q(Pair programming git identity thingy)
+  gem.description = 'Pair programming git identity thingy'
   gem.summary = "Pair harmoniously!  Decide who's driving.  " \
                 "Commit along the way.  Don't make a mess of " \
                 'the repository history.'
-  gem.homepage = 'https://github.com/modcloth/git-duet'
+  gem.homepage = 'https://github.com/meatballhat/git-duet'
   gem.license = 'MIT'
 
-  gem.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
-  gem.executables = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
+  gem.files = `git ls-files -z`.split("\x00")
+  gem.executables = gem.files.grep(/^bin\//)
+                             .map { |f| File.basename(f) }
+                             .reject { |n| n =~ /rubymine-git-wrapper/ }
   gem.test_files = gem.files.grep(/^spec\//)
   gem.name = 'git-duet'
   gem.require_paths = %w(lib)
   gem.version = Git::Duet::VERSION
-  gem.required_ruby_version = '>= 1.9.3'
+  gem.required_ruby_version = '>= 1.9'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'

data/lib/git/duet/version.rb

@@ -3,7 +3,7 @@
 unless defined?(Git::Duet::VERSION)
   module Git
     module Duet
-      VERSION = '0.4.1'
+      VERSION = '0.5.0'
     end
   end
 end

data/spec/lib/git/duet/author_mapper_spec.rb

@@ -27,18 +27,18 @@ describe Git::Duet::AuthorMapper do
   it 'uses an authors file given at initialization' do
     instance = described_class
       .new('/blarggie/blarggie/new/friend/.git-authors')
-    instance.authors_file
-      .should == '/blarggie/blarggie/new/friend/.git-authors'
+    expect(instance.authors_file)
+      .to eq('/blarggie/blarggie/new/friend/.git-authors')
   end
 
   it 'uses the `GIT_DUET_AUTHORS_FILE` if provided' do
     ENV['GIT_DUET_AUTHORS_FILE'] = '/fizzle/bizzle/.git-authors'
     instance = described_class.new
-    instance.authors_file.should == '/fizzle/bizzle/.git-authors'
+    expect(instance.authors_file).to eq('/fizzle/bizzle/.git-authors')
   end
 
   it 'falls back to using `~/.git-authors` for the author map' do
-    subject.authors_file.should == File.join(ENV['HOME'], '.git-authors')
+    expect(subject.authors_file).to eq(File.join(ENV['HOME'], '.git-authors'))
   end
 
   it 'lets missing author errors bubble up' do
@@ -46,41 +46,33 @@ describe Git::Duet::AuthorMapper do
   end
 
   it 'maps initials to name -> email pairs' do
-    subject.map('jd').fetch('jd').should == {
-      name: 'Jane Doe',
-      email: 'jane@awesome.biz'
-    }
+    expect(subject.map('jd').fetch('jd'))
+      .to eq(name: 'Jane Doe', email: 'jane@awesome.biz')
   end
 
   it 'constructs default emails from first initial and last name + domain' do
-    subject.map('hb').should == {
-      'hb' => {
-        name: 'Hampton Bones',
-        email: 'h.bones@awesometown.me'
-      }
-    }
+    expect(subject.map('hb')).to eq('hb' => {
+                                      name: 'Hampton Bones',
+                                      email: 'h.bones@awesometown.me'
+                                    })
   end
 
   it 'constructs emails from optional username (if given) + domain' do
-    subject.map('fb').should == {
-      'fb' => {
-        name: 'Frances Bar',
-        email: 'frances@awesometown.me'
-      }
-    }
+    expect(subject.map('fb')).to eq('fb' => {
+                                      name: 'Frances Bar',
+                                      email: 'frances@awesometown.me'
+                                    })
   end
 
   it 'uses an explicitly-configured email address if given' do
-    subject.map('jd').should == {
-      'jd' => {
-        name: 'Jane Doe',
-        email: 'jane@awesome.biz'
-      }
-    }
+    expect(subject.map('jd')).to eq('jd' => {
+                                      name: 'Jane Doe',
+                                      email: 'jane@awesome.biz'
+                                    })
   end
 
   it 'maps any number of initials to name -> email pairs' do
-    subject.map('jd', 'fb', 'qx', 'hb').should == {
+    expect(subject.map('jd', 'fb', 'qx', 'hb')).to eq(
       'jd' => {
         name: 'Jane Doe',
         email: 'jane@awesome.biz'
@@ -97,38 +89,34 @@ describe Git::Duet::AuthorMapper do
         name: 'Hampton Bones',
         email: 'h.bones@awesometown.me'
       }
-    }
+    )
   end
 
   context 'when using a `~/.pairs` config' do
     before :each do
-      subject.stub(
-        cfg: {
-          'pairs' => {
-            'jd' => 'Jane Doe; jdoe',
-            'fb' => 'Frances Bar; frances',
-            'qx' => 'Quincy Xavier; qx',
-            'hb' => 'Hampton Bones'
-          },
-          'email' => {
-            'domain' => 'awesometown.me'
-          },
-          'email_addresses' => {
-            'jd' => 'jane@awesome.biz'
-          }
+      allow(subject).to receive(:cfg).and_return(
+        'pairs' => {
+          'jd' => 'Jane Doe; jdoe',
+          'fb' => 'Frances Bar; frances',
+          'qx' => 'Quincy Xavier; qx',
+          'hb' => 'Hampton Bones'
+        },
+        'email' => {
+          'domain' => 'awesometown.me'
+        },
+        'email_addresses' => {
+          'jd' => 'jane@awesome.biz'
         }
       )
     end
 
     it 'maps initials to name -> email pairs' do
-      subject.map('jd').fetch('jd').should == {
-        name: 'Jane Doe',
-        email: 'jane@awesome.biz'
-      }
+      expect(subject.map('jd').fetch('jd'))
+        .to eq(name: 'Jane Doe', email: 'jane@awesome.biz')
     end
 
     it 'maps any number of initials to name -> email pairs' do
-      subject.map('jd', 'fb', 'qx', 'hb').should == {
+      expect(subject.map('jd', 'fb', 'qx', 'hb')).to eq(
         'jd' => {
           name: 'Jane Doe',
           email: 'jane@awesome.biz'
@@ -145,7 +133,7 @@ describe Git::Duet::AuthorMapper do
           name: 'Hampton Bones',
           email: 'h.bones@awesometown.me'
         }
-      }
+      )
     end
   end
 
@@ -160,20 +148,20 @@ describe Git::Duet::AuthorMapper do
 
     before :each do
       subject.instance_variable_set(:@cfg, nil)
-      IO.stub(:read).with(bad_path).and_raise(
+      allow(IO).to receive(:read).with(bad_path).and_raise(
         Errno::ENOENT.new("No such file or directory - #{bad_path}")
       )
     end
 
     it 'warns about missing authors file' do
-      $stderr.should_receive(:puts).with(
+      expect($stderr).to receive(:puts).with(
         /Missing or corrupt authors file.*#{bad_path}/i
       )
       expect { subject.map('zzz') }.to raise_error
     end
 
     it 'raises a ScriptDieError' do
-      $stderr.stub(:puts)
+      allow($stderr).to receive(:puts)
       expect { subject.map('zzz') }.to raise_error(Git::Duet::ScriptDieError)
     end
   end

data/spec/lib/git/duet/cli_spec.rb

@@ -8,7 +8,7 @@ describe Git::Duet::Cli do
   subject(:cli) { described_class }
 
   it 'responds to `.main`' do
-    cli.should respond_to(:run)
+    expect(cli).to respond_to(:run)
   end
 
   it 'requires the prog name and argv array' do
@@ -20,28 +20,28 @@ describe Git::Duet::Cli do
   end
 
   it 'returns the exit status from any script error deaths' do
-    cli.stub(:solo).and_raise(Git::Duet::ScriptDieError.new(99))
-    cli.run('git-solo', %w(ty -q)).should == 99
+    allow(cli).to receive(:solo).and_raise(Git::Duet::ScriptDieError.new(99))
+    expect(cli.run('git-solo', %w(ty -q))).to eq(99)
   end
 
   it 'runs `solo` when the progname matches /solo$/' do
-    Git::Duet::SoloCommand.stub(new: double('solo').tap do |solo|
-      solo.should_receive(:execute!)
-    end)
+    allow(Git::Duet::SoloCommand).to receive(:new).and_return(
+      double('solo').tap { |solo| expect(solo).to receive(:execute!) }
+    )
     cli.run('git-solo', %w(jd -q))
   end
 
   it 'runs `duet` when progname matches /duet$/' do
-    Git::Duet::DuetCommand.stub(new: double('duet').tap do |duet|
-      duet.should_receive(:execute!)
-    end)
+    allow(Git::Duet::DuetCommand).to receive(:new).and_return(
+      double('duet').tap { |duet| expect(duet).to receive(:execute!) }
+    )
     cli.run('git-duet', %w(jd fb -q))
   end
 
   it 'runs `pre_commit` when progname matches /pre-commit$/' do
-    Git::Duet::PreCommitCommand.stub(new: double('pre-commit').tap do |pc|
-      pc.should_receive(:execute!)
-    end)
+    allow(Git::Duet::PreCommitCommand).to receive(:new).and_return(
+      double('pre-commit').tap { |pc| expect(pc).to receive(:execute!) }
+    )
     cli.run('git-duet-pre-commit', %w(-q))
   end
 end

data/spec/lib/git/duet/command_methods_spec.rb

@@ -17,26 +17,26 @@ describe Git::Duet::CommandMethods do
 
   before :each do
     [:info, :error].each do |m|
-      subject.stub(m)
+      allow(subject).to receive(m)
     end
-    subject.stub(:in_repo_root) do |&block|
+    allow(subject).to receive(:in_repo_root) do |&block|
       block.call
     end
   end
 
   it 'writes env vars to a custom git config tree' do
-    subject.should_receive(:`)
+    expect(subject).to receive(:`)
       .with("git config #{Git::Duet::Config.namespace}.fizzle-baz 'awesome'")
-    subject.should_receive(:`)
+    expect(subject).to receive(:`)
       .with("git config #{Git::Duet::Config.namespace}.oh-snarf 'mumra'")
-    subject.should_receive(:`)
+    expect(subject).to receive(:`)
       .with(/^git config #{Git::Duet::Config.namespace}.mtime \d+/)
     subject.send(:write_env_vars)
   end
 
   it 'explodes if a subshell returns non-zero' do
-    subject.stub(:`)
-    $CHILD_STATUS.should_receive(:exitstatus).and_return(1)
+    allow(subject).to receive(:`)
+    expect($CHILD_STATUS).to receive(:exitstatus).and_return(1)
     expect { subject.send(:exec_check, 'ls hamsters') }
       .to raise_error(StandardError)
   end
@@ -47,13 +47,13 @@ describe Git::Duet::CommandMethods do
     end
 
     it 'writes env vars to a custom global git config tree' do
-      subject.should_receive(:`)
+      expect(subject).to receive(:`)
         .with("git config --global #{Git::Duet::Config.namespace}" \
               ".fizzle-baz 'awesome'")
-      subject.should_receive(:`)
+      expect(subject).to receive(:`)
         .with("git config --global #{Git::Duet::Config.namespace}" \
               ".oh-snarf 'mumra'")
-      subject.should_receive(:`)
+      expect(subject).to receive(:`)
         .with(/^git config --global #{Git::Duet::Config.namespace}.mtime \d+/)
       subject.send(:write_env_vars)
     end

data/spec/lib/git/duet/duet_command_spec.rb

@@ -10,15 +10,17 @@ describe Git::Duet::DuetCommand do
   subject(:cmd) { described_class.new(alpha, omega) }
 
   before :each do
-    cmd.stub(author_mapper: double('author mapper').tap do |am|
-      am.stub(map: author_mapping)
-    end)
-    cmd.stub(:` => '')
-    cmd.stub(:report_env_vars)
-    Dir.stub(:chdir) do |&block|
+    allow(cmd).to receive(:author_mapper).and_return(
+      double('author mapper').tap do |am|
+        allow(am).to receive(:map).and_return(author_mapping)
+      end
+    )
+    allow(cmd).to receive(:`).and_return('')
+    allow(cmd).to receive(:report_env_vars)
+    allow(Dir).to receive(:chdir) do |&block|
       block.call
     end
-    File.stub(:open) do |_, _, &block|
+    allow(File).to receive(:open) do |_, _, &block|
       block.call(double('outfile').as_null_object)
     end
   end
@@ -28,42 +30,42 @@ describe Git::Duet::DuetCommand do
   end
 
   it 'responds to `execute!`' do
-    cmd.should respond_to(:execute!)
+    expect(cmd).to respond_to(:execute!)
   end
 
   it '(privately) responds to `write_env_vars`' do
-    cmd.private_methods.map(&:to_sym).should include(:write_env_vars)
+    expect(cmd.private_methods.map(&:to_sym)).to include(:write_env_vars)
   end
 
   it 'sets the alpha name as git config user.name' do
-    cmd.stub(:`).with(/git config user\.email/)
-    cmd.should_receive(:`)
+    allow(cmd).to receive(:`).with(/git config user\.email/)
+    expect(cmd).to receive(:`)
       .with("git config user.name '#{author_mapping[alpha][:name]}'")
     cmd.execute!
   end
 
   it 'sets the alpha email as git config user.email' do
-    cmd.stub(:`).with(/git config user\.name/)
-    cmd.should_receive(:`)
+    allow(cmd).to receive(:`).with(/git config user\.name/)
+    expect(cmd).to receive(:`)
       .with("git config user.email '#{author_mapping[alpha][:email]}'")
     cmd.execute!
   end
 
   it 'reports env vars to $stdout' do
-    cmd.unstub(:report_env_vars)
-    $stdout.should_receive(:puts)
+    expect(cmd).to receive(:report_env_vars).and_call_original
+    expect($stdout).to receive(:puts)
       .with(/^GIT_AUTHOR_NAME='#{author_mapping[alpha][:name]}'/)
-    $stdout.should_receive(:puts)
+    expect($stdout).to receive(:puts)
       .with(/^GIT_AUTHOR_EMAIL='#{author_mapping[alpha][:email]}'/)
-    $stdout.should_receive(:puts)
+    expect($stdout).to receive(:puts)
       .with(/^GIT_COMMITTER_NAME='#{author_mapping[omega][:name]}'/)
-    $stdout.should_receive(:puts)
+    expect($stdout).to receive(:puts)
       .with(/^GIT_COMMITTER_EMAIL='#{author_mapping[omega][:email]}'/)
     cmd.execute!
   end
 
   it 'sets the alpha as author and omega as committer in custom git config' do
-    cmd.should_receive(:write_env_vars)
+    expect(cmd).to receive(:write_env_vars)
     cmd.execute!
   end
 
@@ -72,7 +74,7 @@ describe Git::Duet::DuetCommand do
       let(:"#{author_type}") { 'brzzzt' }
 
       it 'aborts' do
-        cmd.stub(error: nil)
+        allow(cmd).to receive(:error).and_return(nil)
         expect { cmd.execute! }.to raise_error(Git::Duet::ScriptDieError)
       end
     end
@@ -82,17 +84,17 @@ describe Git::Duet::DuetCommand do
     subject(:cmd) { described_class.new(alpha, omega, false, true) }
 
     it 'sets the alpha name as global git config user.name' do
-      cmd.stub(:`).with(/git config --global user\.email/)
+      allow(cmd).to receive(:`).with(/git config --global user\.email/)
       alpha_name = author_mapping[alpha][:name]
-      cmd.should_receive(:`)
+      expect(cmd).to receive(:`)
         .with("git config --global user.name '#{alpha_name}'")
       cmd.execute!
     end
 
     it 'sets the alpha email as global git config user.email' do
-      cmd.stub(:`).with(/git config --global user\.name/)
+      allow(cmd).to receive(:`).with(/git config --global user\.name/)
       alpha_email = author_mapping[alpha][:email]
-      cmd.should_receive(:`)
+      expect(cmd).to receive(:`)
         .with("git config --global user.email '#{alpha_email}'")
       cmd.execute!
     end
@@ -111,11 +113,11 @@ describe Git::Duet::DuetCommand do
         #{Git::Duet::Config.namespace}.mtime 138039#{rand(1000..9999)}
       EOF
 
-      cmd.stub(:`)
+      allow(cmd).to receive(:`)
         .with("git config --get-regexp #{Git::Duet::Config.namespace}") do
         git_config_output
       end
-      $stdout.should_receive(:puts).with(git_config_output)
+      expect($stdout).to receive(:puts).with(git_config_output)
 
       cmd.execute!
     end

data/spec/lib/git/duet/pre_commit_command_spec.rb

@@ -5,7 +5,7 @@ describe Git::Duet::PreCommitCommand do
   subject(:cmd) { described_class.new(true) }
 
   before :each do
-    cmd.stub(:in_repo_root) do |&block|
+    allow(cmd).to receive(:in_repo_root) do |&block|
       block.call
     end
     @old_seconds_ago_stale = ENV.delete('GIT_DUET_SECONDS_AGO_STALE')
@@ -21,19 +21,19 @@ describe Git::Duet::PreCommitCommand do
   end
 
   it 'does nothing if the env cache is not stale' do
-    cmd.stub(:exec_check)
+    allow(cmd).to receive(:exec_check)
       .with(/git config #{Git::Duet::Config.namespace}.git/)
-    cmd.stub(:exec_check)
+    allow(cmd).to receive(:exec_check)
       .with("git config #{Git::Duet::Config.namespace}.mtime")
       .and_return(Time.now.to_i)
-    cmd.should_not_receive(:explode!)
+    expect(cmd).to_not receive(:explode!)
     cmd.execute!
   end
 
   it 'explodes if the env cache does not exist' do
-    cmd.stub(:exec_check)
+    allow(cmd).to receive(:exec_check)
       .with(/git config #{Git::Duet::Config.namespace}.git/)
-    cmd.stub(:exec_check)
+    allow(cmd).to receive(:exec_check)
       .with("git config #{Git::Duet::Config.namespace}.mtime")
       .and_raise(StandardError)
     expect { cmd.execute! }.to raise_error(Git::Duet::ScriptDieError)

data/spec/lib/git/duet/solo_command_spec.rb

@@ -10,12 +10,14 @@ describe Git::Duet::SoloCommand do
   subject(:cmd) { described_class.new(soloist) }
 
   before :each do
-    cmd.stub(author_mapper: double('author mapper').tap do |am|
-      am.stub(map: author_mapping)
-    end)
-    cmd.stub(:` => '')
-    cmd.stub(:report_env_vars)
-    cmd.stub(:in_repo_root) do |&block|
+    allow(cmd).to receive(:author_mapper).and_return(
+      double('author mapper').tap do |am|
+        allow(am).to receive(:map).and_return(author_mapping)
+      end
+    )
+    allow(cmd).to receive(:`).and_return('')
+    allow(cmd).to receive(:report_env_vars)
+    allow(cmd).to receive(:in_repo_root) do |&block|
       block.call
     end
   end
@@ -25,64 +27,68 @@ describe Git::Duet::SoloCommand do
   end
 
   it 'responds to `execute!`' do
-    cmd.should respond_to(:execute!)
+    expect(cmd).to respond_to(:execute!)
   end
 
   it '(privately) responds to `write_env_vars`' do
-    cmd.private_methods.map(&:to_sym).should include(:write_env_vars)
+    expect(cmd.private_methods.map(&:to_sym)).to include(:write_env_vars)
   end
 
   it 'sets the soloist name as git config user.name' do
-    cmd.stub(:`).with(/git config user\.email/)
-    cmd.stub(:`).with(/git config --unset-all #{Git::Duet::Config.namespace}/)
-    cmd.should_receive(:`)
+    allow(cmd).to receive(:`).with(/git config user\.email/)
+    allow(cmd).to receive(:`).with(
+      /git config --unset-all #{Git::Duet::Config.namespace}/
+    )
+    expect(cmd).to receive(:`)
       .with("git config user.name '#{author_mapping[soloist][:name]}'")
     cmd.execute!
   end
 
   it 'sets the soloist email as git config user.email' do
-    cmd.stub(:`).with(/git config user\.name/)
-    cmd.stub(:`).with(/git config --unset-all #{Git::Duet::Config.namespace}/)
-    cmd.should_receive(:`)
+    allow(cmd).to receive(:`).with(/git config user\.name/)
+    allow(cmd).to receive(:`).with(
+      /git config --unset-all #{Git::Duet::Config.namespace}/
+    )
+    expect(cmd).to receive(:`)
       .with("git config user.email '#{author_mapping[soloist][:email]}'")
     cmd.execute!
   end
 
   it 'unsets the committer name' do
-    cmd.stub(:`).with(/git config user\.name/)
-    cmd.stub(:`).with(/git config user\.email/)
-    cmd.stub(:`)
+    allow(cmd).to receive(:`).with(/git config user\.name/)
+    allow(cmd).to receive(:`).with(/git config user\.email/)
+    allow(cmd).to receive(:`)
       .with(/git config --unset-all #{Git::Duet::Config
                                       .namespace}.git-committer-email/)
-    cmd.should_receive(:`)
+    expect(cmd).to receive(:`)
       .with("git config --unset-all #{Git::Duet::Config
                                       .namespace}.git-committer-name")
     cmd.execute!
   end
 
   it 'unsets the committer email' do
-    cmd.stub(:`).with(/git config user\.name/)
-    cmd.stub(:`).with(/git config user\.email/)
-    cmd.stub(:`)
+    allow(cmd).to receive(:`).with(/git config user\.name/)
+    allow(cmd).to receive(:`).with(/git config user\.email/)
+    allow(cmd).to receive(:`)
       .with(/git config --unset-all #{Git::Duet::Config
                                       .namespace}.git-committer-name/)
-    cmd.should_receive(:`)
+    expect(cmd).to receive(:`)
       .with("git config --unset-all #{Git::Duet::Config
                                       .namespace}.git-committer-email")
     cmd.execute!
   end
 
   it 'reports env vars to $stdout' do
-    cmd.unstub(:report_env_vars)
-    $stdout.should_receive(:puts)
+    allow(cmd).to receive(:report_env_vars).and_call_original
+    expect($stdout).to receive(:puts)
       .with(/^GIT_AUTHOR_NAME='#{author_mapping[soloist][:name]}'/)
-    $stdout.should_receive(:puts)
+    expect($stdout).to receive(:puts)
       .with(/^GIT_AUTHOR_EMAIL='#{author_mapping[soloist][:email]}'/)
     cmd.execute!
   end
 
   it 'sets the soloist as author in custom git config' do
-    cmd.should_receive(:write_env_vars)
+    expect(cmd).to receive(:write_env_vars)
     cmd.execute!
   end
 
@@ -90,7 +96,7 @@ describe Git::Duet::SoloCommand do
     let(:soloist) { 'bzzzrt' }
 
     it 'aborts' do
-      cmd.stub(error: nil)
+      allow(cmd).to receive(:error).and_return(nil)
       expect { cmd.execute! }.to raise_error(Git::Duet::ScriptDieError)
     end
   end
@@ -105,11 +111,11 @@ describe Git::Duet::SoloCommand do
         #{Git::Duet::Config.namespace}.mtime 138039#{rand(1000..9999)}
       EOF
 
-      cmd.stub(:`)
+      allow(cmd).to receive(:`)
         .with("git config --get-regexp #{Git::Duet::Config.namespace}") do
         git_config_output
       end
-      $stdout.should_receive(:puts).with(git_config_output)
+      expect($stdout).to receive(:puts).with(git_config_output)
 
       cmd.execute!
     end
@@ -119,48 +125,48 @@ describe Git::Duet::SoloCommand do
     subject(:cmd) { described_class.new(soloist, false, true) }
 
     it 'sets the soloist name as global git config user.name' do
-      cmd.stub(:`).with(/git config --global user\.email/)
-      cmd.stub(:`)
+      allow(cmd).to receive(:`).with(/git config --global user\.email/)
+      allow(cmd).to receive(:`)
         .with(/git config --global --unset-all #{Git::Duet::Config.namespace}/)
       soloist_name = author_mapping[soloist][:name]
-      cmd.should_receive(:`)
+      expect(cmd).to receive(:`)
         .with("git config --global user.name '#{soloist_name}'")
       cmd.execute!
     end
 
     it 'sets the soloist email as global git config user.email' do
-      cmd.stub(:`).with(/git config --global user\.name/)
-      cmd.stub(:`)
+      allow(cmd).to receive(:`).with(/git config --global user\.name/)
+      allow(cmd).to receive(:`)
         .with(/git config --global --unset-all #{Git::Duet::Config.namespace}/)
       soloist_email = author_mapping[soloist][:email]
-      cmd.should_receive(:`)
+      expect(cmd).to receive(:`)
         .with("git config --global user.email '#{soloist_email}'")
       cmd.execute!
     end
 
     it 'unsets the global committer name' do
-      cmd.stub(:`).with(/git config --global user\.name/)
-      cmd.stub(:`).with(/git config --global user\.email/)
-      cmd.stub(:`)
+      allow(cmd).to receive(:`).with(/git config --global user\.name/)
+      allow(cmd).to receive(:`).with(/git config --global user\.email/)
+      allow(cmd).to receive(:`)
         .with(
           /git config --global --unset-all #{Git::Duet::Config
                                              .namespace}.git-committer-email/
         )
-      cmd.should_receive(:`)
+      expect(cmd).to receive(:`)
         .with('git config --global --unset-all ' \
               "#{Git::Duet::Config.namespace}.git-committer-name")
       cmd.execute!
     end
 
     it 'unsets the global committer email' do
-      cmd.stub(:`).with(/git config --global user\.name/)
-      cmd.stub(:`).with(/git config --global user\.email/)
-      cmd.stub(:`)
+      allow(cmd).to receive(:`).with(/git config --global user\.name/)
+      allow(cmd).to receive(:`).with(/git config --global user\.email/)
+      allow(cmd).to receive(:`)
         .with(
           /git config --global --unset-all #{Git::Duet::Config
                                              .namespace}.git-committer-name/
         )
-      cmd.should_receive(:`)
+      expect(cmd).to receive(:`)
         .with('git config --global --unset-all ' \
               "#{Git::Duet::Config.namespace}.git-committer-email")
       cmd.execute!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-duet
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Dan Buch
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -99,10 +99,10 @@ dependencies:
         version: '0'
 description: Pair programming git identity thingy
 email:
-- d.buch@modcloth.com
-- j.szwedko@modcloth.com
-- r.colton@modcloth.com
-- sp.mccoy@modcloth.com
+- dan@meatballhat.com
+- jesse.szwedko@gmail.com
+- rafael.colton@gmail.com
+- sheenathejunglegirl@gmail.com
 executables:
 - git-duet
 - git-duet-commit
@@ -128,6 +128,8 @@ files:
 - bin/git-duet-install-hook
 - bin/git-duet-pre-commit
 - bin/git-solo
+- bin/rubymine-git-wrapper
+- file.txt
 - git-duet.gemspec
 - lib/git-duet.rb
 - lib/git/duet.rb
@@ -155,7 +157,7 @@ files:
 - test/git-duet.bats
 - test/git-solo.bats
 - test/test_helper.bash
-homepage: https://github.com/modcloth/git-duet
+homepage: https://github.com/meatballhat/git-duet
 licenses:
 - MIT
 metadata: {}
@@ -167,7 +169,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="