git-duet 0.1.3 → 0.2.0

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

@@ -1,3 +1,4 @@
+# vim:fileencoding=utf-8
 require 'git/duet/author_mapper'
 
 describe Git::Duet::AuthorMapper do
@@ -22,83 +23,85 @@ describe Git::Duet::AuthorMapper do
     ENV.delete('GIT_DUET_AUTHORS_FILE')
   end
 
-  it 'should use 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'
+  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'
   end
 
-  it 'should use the `GIT_DUET_AUTHORS_FILE` if provided' do
+  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'
   end
 
-  it 'should fall back to using `~/.git-authors` for the author map' do
+  it 'falls back to using `~/.git-authors` for the author map' do
     subject.authors_file.should == File.join(ENV['HOME'], '.git-authors')
   end
 
-  it 'should let missing author errors bubble up' do
+  it 'lets missing author errors bubble up' do
     expect { subject.map('bzzzrt') }.to raise_error
   end
 
-  it 'should map initials to name -> email pairs' do
+  it 'maps initials to name -> email pairs' do
     subject.map('jd').fetch('jd').should == {
-      :name => 'Jane Doe',
-      :email => 'jane@awesome.biz'
+      name: 'Jane Doe',
+      email: 'jane@awesome.biz'
     }
   end
 
-  it 'should construct default email addresses from first initial and last name plus domain' do
+  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'
+        name: 'Hampton Bones',
+        email: 'h.bones@awesometown.me'
       }
     }
   end
 
-  it 'should construct email addresses from optional username (if given) plus domain' do
+  it 'constructs emails from optional username (if given) + domain' do
     subject.map('fb').should == {
       'fb' => {
-        :name => 'Frances Bar',
-        :email => 'frances@awesometown.me'
+        name: 'Frances Bar',
+        email: 'frances@awesometown.me'
       }
     }
   end
 
-  it 'should use an explicitly-configured email address if given' do
+  it 'uses an explicitly-configured email address if given' do
     subject.map('jd').should == {
       'jd' => {
-        :name => 'Jane Doe',
-        :email => 'jane@awesome.biz'
+        name: 'Jane Doe',
+        email: 'jane@awesome.biz'
       }
     }
   end
 
-  it 'should map any number of initials to name -> email pairs' do
+  it 'maps any number of initials to name -> email pairs' do
     subject.map('jd', 'fb', 'qx', 'hb').should == {
       'jd' => {
-        :name => 'Jane Doe',
-        :email => 'jane@awesome.biz'
+        name: 'Jane Doe',
+        email: 'jane@awesome.biz'
       },
       'fb' => {
-        :name => 'Frances Bar',
-        :email => 'frances@awesometown.me'
+        name: 'Frances Bar',
+        email: 'frances@awesometown.me'
       },
       'qx' => {
-        :name => 'Quincy Xavier',
-        :email => 'qx@awesometown.me'
+        name: 'Quincy Xavier',
+        email: 'qx@awesometown.me'
       },
       'hb' => {
-        :name => 'Hampton Bones',
-        :email => 'h.bones@awesometown.me'
+        name: 'Hampton Bones',
+        email: 'h.bones@awesometown.me'
       }
     }
   end
 
   context 'when using a `~/.pairs` config' do
     before :each do
-      subject.stub(:cfg => {
+      subject.stub(cfg: {
         'pairs' => {
           'jd' => 'Jane Doe; jdoe',
           'fb' => 'Frances Bar; frances',
@@ -114,30 +117,30 @@ describe Git::Duet::AuthorMapper do
       })
     end
 
-    it 'should map initials to name -> email pairs' do
+    it 'maps initials to name -> email pairs' do
       subject.map('jd').fetch('jd').should == {
-        :name => 'Jane Doe',
-        :email => 'jane@awesome.biz'
+        name: 'Jane Doe',
+        email: 'jane@awesome.biz'
       }
     end
 
-    it 'should map any number of initials to name -> email pairs' do
+    it 'maps any number of initials to name -> email pairs' do
       subject.map('jd', 'fb', 'qx', 'hb').should == {
         'jd' => {
-          :name => 'Jane Doe',
-          :email => 'jane@awesome.biz'
+          name: 'Jane Doe',
+          email: 'jane@awesome.biz'
         },
         'fb' => {
-          :name => 'Frances Bar',
-          :email => 'frances@awesometown.me'
+          name: 'Frances Bar',
+          email: 'frances@awesometown.me'
         },
         'qx' => {
-          :name => 'Quincy Xavier',
-          :email => 'qx@awesometown.me'
+          name: 'Quincy Xavier',
+          email: 'qx@awesometown.me'
         },
         'hb' => {
-          :name => 'Hampton Bones',
-          :email => 'h.bones@awesometown.me'
+          name: 'Hampton Bones',
+          email: 'h.bones@awesometown.me'
         }
       }
     end
@@ -159,14 +162,14 @@ describe Git::Duet::AuthorMapper do
       )
     end
 
-    it 'should warn about missing authors file' do
+    it 'warns about missing authors file' do
       $stderr.should_receive(:puts).with(
         /Missing or corrupt authors file.*#{bad_path}/i
       )
       expect { subject.map('zzz') }.to raise_error
     end
 
-    it 'should raise a ScriptDieError' do
+    it 'raises a ScriptDieError' do
       $stderr.stub(:puts)
       expect { subject.map('zzz') }.to raise_error(Git::Duet::ScriptDieError)
     end

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

@@ -1,46 +1,47 @@
+# vim:fileencoding=utf-8
 require 'git/duet/cli'
 require 'git/duet/solo_command'
 require 'git/duet/duet_command'
 require 'git/duet/pre_commit_command'
 
 describe Git::Duet::Cli do
-  subject { described_class }
+  subject(:cli) { described_class }
 
-  it 'should respond to .main`' do
-    subject.should respond_to(:run)
+  it 'responds to `.main`' do
+    cli.should respond_to(:run)
   end
 
-  it 'should require the prog name and argv array' do
-    expect { subject.run }.to raise_error(ArgumentError)
+  it 'requires the prog name and argv array' do
+    expect { cli.run }.to raise_error(ArgumentError)
   end
 
-  it 'should explode on unknown prog names' do
-    expect { subject.run('bork', []) }.to raise_error(ScriptError)
+  it 'explodes on unknown prog names' do
+    expect { cli.run('bork', []) }.to raise_error(ScriptError)
   end
 
-  it 'should return the exit status from any script error deaths' do
-    subject.stub(:solo).and_raise(Git::Duet::ScriptDieError.new(99))
-    subject.run('git-solo', %w(ty -q)).should == 99
+  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
   end
 
-  it 'should run `solo` when the progname matches /solo$/' do
-    Git::Duet::SoloCommand.stub(:new => double('solo').tap do |solo|
+  it 'runs `solo` when the progname matches /solo$/' do
+    Git::Duet::SoloCommand.stub(new: double('solo').tap do |solo|
       solo.should_receive(:execute!)
     end)
-    subject.run('git-solo', %w(jd -q))
+    cli.run('git-solo', %w(jd -q))
   end
 
-  it 'should run `duet` when progname matches /duet$/' do
-    Git::Duet::DuetCommand.stub(:new => double('duet').tap do |duet|
+  it 'runs `duet` when progname matches /duet$/' do
+    Git::Duet::DuetCommand.stub(new: double('duet').tap do |duet|
       duet.should_receive(:execute!)
     end)
-    subject.run('git-duet', %w(jd fb -q))
+    cli.run('git-duet', %w(jd fb -q))
   end
 
-  it 'should run `pre_commit` when progname matches /pre-commit$/' do
-    Git::Duet::PreCommitCommand.stub(:new => double('pre-commit').tap do |pc|
+  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)
-    subject.run('git-duet-pre-commit', %w(-q))
+    cli.run('git-duet-pre-commit', %w(-q))
   end
 end

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

@@ -1,3 +1,4 @@
+# vim:fileencoding=utf-8
 require 'git/duet/command_methods'
 
 describe Git::Duet::CommandMethods do
@@ -23,17 +24,21 @@ describe Git::Duet::CommandMethods do
     end
   end
 
-  it 'should write env vars to a custom git config tree' do
-    subject.should_receive(:`).with("git config duet.env.fizzle-baz 'awesome'")
-    subject.should_receive(:`).with("git config duet.env.oh-snarf 'mumra'")
-    subject.should_receive(:`).with(/^git config duet\.env\.mtime \d+/)
+  it 'writes env vars to a custom git config tree' do
+    subject.should_receive(:`)
+      .with("git config #{Git::Duet::Config.namespace}.fizzle-baz 'awesome'")
+    subject.should_receive(:`)
+      .with("git config #{Git::Duet::Config.namespace}.oh-snarf 'mumra'")
+    subject.should_receive(:`)
+      .with(/^git config #{Git::Duet::Config.namespace}.mtime \d+/)
     subject.send(:write_env_vars)
   end
 
-  it 'should explode if a subshell returns non-zero' do
+  it 'explodes if a subshell returns non-zero' do
     subject.stub(:`)
-    $?.should_receive(:exitstatus).and_return(1)
-    expect { subject.send(:exec_check, 'ls hamsters') }.to raise_error(StandardError)
+    $CHILD_STATUS.should_receive(:exitstatus).and_return(1)
+    expect { subject.send(:exec_check, 'ls hamsters') }
+      .to raise_error(StandardError)
   end
 
   context 'when configured to operate on the global config' do
@@ -41,10 +46,15 @@ describe Git::Duet::CommandMethods do
       subject.instance_variable_set(:@global, true)
     end
 
-    it 'should write env vars to a custom global git config tree' do
-      subject.should_receive(:`).with("git config --global duet.env.fizzle-baz 'awesome'")
-      subject.should_receive(:`).with("git config --global duet.env.oh-snarf 'mumra'")
-      subject.should_receive(:`).with(/^git config --global duet\.env\.mtime \d+/)
+    it 'writes env vars to a custom global git config tree' do
+      subject.should_receive(:`)
+        .with("git config --global #{Git::Duet::Config.namespace}" <<
+              ".fizzle-baz 'awesome'")
+      subject.should_receive(:`)
+        .with("git config --global #{Git::Duet::Config.namespace}" <<
+              ".oh-snarf 'mumra'")
+      subject.should_receive(:`)
+        .with(/^git config --global #{Git::Duet::Config.namespace}.mtime \d+/)
       subject.send(:write_env_vars)
     end
   end

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

@@ -1,71 +1,70 @@
+# vim:fileencoding=utf-8
 require 'git/duet/duet_command'
 require 'support/author_mapper_helper'
 
 describe Git::Duet::DuetCommand do
   include SpecSupport::AuthorMapperHelper
 
-  let :alpha do
-    random_author
-  end
-
-  let :omega do
-    random_author
-  end
-
-  subject do
-    described_class.new(alpha, omega)
-  end
+  let(:alpha) { random_author }
+  let(:omega) { random_author }
+  subject(:cmd) { described_class.new(alpha, omega) }
 
   before :each do
-    subject.stub(:author_mapper => double('author mapper').tap do |am|
-      am.stub(:map => author_mapping)
+    cmd.stub(author_mapper: double('author mapper').tap do |am|
+      am.stub(map: author_mapping)
     end)
-    subject.stub(:` => '')
-    subject.stub(:report_env_vars)
+    cmd.stub(:` => '')
+    cmd.stub(:report_env_vars)
     Dir.stub(:chdir) do |&block|
       block.call
     end
-    File.stub(:open) do |filename,mode,&block|
+    File.stub(:open) do |filename, mode, &block|
       block.call(double('outfile').as_null_object)
     end
   end
 
-  it 'should require alpha and omega sets of initials' do
+  it 'requires alpha and omega sets of initials' do
     expect { described_class.new }.to raise_error(ArgumentError)
   end
 
-  it 'should respond to `execute!`' do
-    subject.should respond_to(:execute!)
+  it 'responds to `execute!`' do
+    cmd.should respond_to(:execute!)
   end
 
-  it 'should (privately) respond to `write_env_vars`' do
-    subject.private_methods.map(&:to_sym).should include(:write_env_vars)
+  it '(privately) responds to `write_env_vars`' do
+    cmd.private_methods.map(&:to_sym).should include(:write_env_vars)
   end
 
-  it 'should set the alpha name as git config user.name' do
-    subject.stub(:`).with(/git config user\.email/)
-    subject.should_receive(:`).with("git config user.name '#{author_mapping[alpha][:name]}'")
-    subject.execute!
+  it 'sets the alpha name as git config user.name' do
+    cmd.stub(:`).with(/git config user\.email/)
+    cmd.should_receive(:`)
+      .with("git config user.name '#{author_mapping[alpha][:name]}'")
+    cmd.execute!
   end
 
-  it 'should set the alpha email as git config user.email' do
-    subject.stub(:`).with(/git config user\.name/)
-    subject.should_receive(:`).with("git config user.email '#{author_mapping[alpha][:email]}'")
-    subject.execute!
+  it 'sets the alpha email as git config user.email' do
+    cmd.stub(:`).with(/git config user\.name/)
+    cmd.should_receive(:`)
+      .with("git config user.email '#{author_mapping[alpha][:email]}'")
+    cmd.execute!
   end
 
-  it 'should report env vars to $stdout' do
-    subject.unstub(:report_env_vars)
-    $stdout.should_receive(:puts).with(/^GIT_AUTHOR_NAME='#{author_mapping[alpha][:name]}'/)
-    $stdout.should_receive(:puts).with(/^GIT_AUTHOR_EMAIL='#{author_mapping[alpha][:email]}'/)
-    $stdout.should_receive(:puts).with(/^GIT_COMMITTER_NAME='#{author_mapping[omega][:name]}'/)
-    $stdout.should_receive(:puts).with(/^GIT_COMMITTER_EMAIL='#{author_mapping[omega][:email]}'/)
-    subject.execute!
+  it 'reports env vars to $stdout' do
+    cmd.unstub(:report_env_vars)
+    $stdout.should_receive(:puts)
+      .with(/^GIT_AUTHOR_NAME='#{author_mapping[alpha][:name]}'/)
+    $stdout.should_receive(:puts)
+      .with(/^GIT_AUTHOR_EMAIL='#{author_mapping[alpha][:email]}'/)
+    $stdout.should_receive(:puts)
+      .with(/^GIT_COMMITTER_NAME='#{author_mapping[omega][:name]}'/)
+    $stdout.should_receive(:puts)
+      .with(/^GIT_COMMITTER_EMAIL='#{author_mapping[omega][:email]}'/)
+    cmd.execute!
   end
 
-  it 'should set the alpha as author and omega as committer in custom git config' do
-    subject.should_receive(:write_env_vars)
-    subject.execute!
+  it 'sets the alpha as author and omega as committer in custom git config' do
+    cmd.should_receive(:write_env_vars)
+    cmd.execute!
   end
 
   %w(alpha omega).each do |author_type|
@@ -73,27 +72,52 @@ describe Git::Duet::DuetCommand do
       let(:"#{author_type}") { 'brzzzt' }
 
       it 'aborts' do
-        subject.stub(:error => nil)
-        expect { subject.execute! }.to raise_error(Git::Duet::ScriptDieError)
+        cmd.stub(error: nil)
+        expect { cmd.execute! }.to raise_error(Git::Duet::ScriptDieError)
       end
     end
   end
 
   context 'when configured to operate on the global config' do
-    subject do
-      described_class.new(alpha, omega, false, true)
+    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/)
+      alpha_name = author_mapping[alpha][:name]
+      cmd.should_receive(:`)
+        .with("git config --global user.name '#{alpha_name}'")
+      cmd.execute!
     end
 
-    it 'should set the alpha name as global git config user.name' do
-      subject.stub(:`).with(/git config --global user\.email/)
-      subject.should_receive(:`).with("git config --global user.name '#{author_mapping[alpha][:name]}'")
-      subject.execute!
+    it 'sets the alpha email as global git config user.email' do
+      cmd.stub(:`).with(/git config --global user\.name/)
+      alpha_email = author_mapping[alpha][:email]
+      cmd.should_receive(:`)
+        .with("git config --global user.email '#{alpha_email}'")
+      cmd.execute!
     end
+  end
+
+  context 'when given no arguments' do
+    let(:alpha) { nil }
+    let(:omega) { nil }
+
+    it 'shows the current duet author settings' do
+      git_config_output = <<-EOF.gsub(/^ {8}/, '')
+        #{Git::Duet::Config.namespace}.git-author-name Test Author
+        #{Git::Duet::Config.namespace}.git-author-email author@test.com
+        #{Git::Duet::Config.namespace}.git-committer-name Test Committer
+        #{Git::Duet::Config.namespace}.git-committer-email committer@test.com
+        #{Git::Duet::Config.namespace}.mtime 138039#{rand(1000..9999)}
+      EOF
+
+      cmd.stub(:`)
+        .with("git config --get-regexp #{Git::Duet::Config.namespace}") do
+        git_config_output
+      end
+      $stdout.should_receive(:puts).with(git_config_output)
 
-    it 'should set the alpha email as global git config user.email' do
-      subject.stub(:`).with(/git config --global user\.name/)
-      subject.should_receive(:`).with("git config --global user.email '#{author_mapping[alpha][:email]}'")
-      subject.execute!
+      cmd.execute!
     end
   end
 end