ppl 3.0.0 → 4.0.3

data/spec/ppl/adapter/storage_spec.rb

@@ -1,4 +1,3 @@
-
 describe Ppl::Adapter::Storage do
 
   before(:each) do
@@ -32,13 +31,13 @@ describe Ppl::Adapter::Storage do
   describe "#require_contact" do
 
     it "should raise Ppl::Error::ContactNotFound if load fails" do
-      @storage.stub(:load_contact) do |id| end
+      allow(@storage).to receive(:load_contact) do |id| end
       expect{@storage.require_contact("joe")}.to raise_error(Ppl::Error::ContactNotFound)
     end
 
     it "should return the loaded contact" do
-      @storage.stub(:load_contact) do |id| Object.new end
-      @storage.require_contact("joe").should be_an(Object)
+      allow(@storage).to receive(:load_contact) do |id| Object.new end
+      expect(@storage.require_contact("joe")).to be_an(Object)
     end
   end
 

data/spec/ppl/adapter/vcard/greencard_spec.rb

@@ -11,70 +11,70 @@ describe Ppl::Adapter::Vcard::Vpim, "#encode" do
 
   it "should encode the contact's birthday" do
     @contact.birthday = Date.parse "2000-01-01"
-    @adapter.encode(@contact).should include("BDAY:20000101")
+    expect(@adapter.encode(@contact)).to include("BDAY:20000101")
   end
 
   it "should encode the contact's full name" do
     @contact.name.full = "John Doe"
-    @adapter.encode(@contact).should include("FN:John Doe")
+    expect(@adapter.encode(@contact)).to include("FN:John Doe")
   end
 
   it "should encode the contact's given name" do
     @contact.name.given = "John"
-    @adapter.encode(@contact).should include("N:;John;;;")
+    expect(@adapter.encode(@contact)).to include("N:;John;;;")
   end
 
   it "should encode the contact's family name" do
     @contact.name.family = "Smith"
-    @adapter.encode(@contact).should include("N:Smith;;;;")
+    expect(@adapter.encode(@contact)).to include("N:Smith;;;;")
   end
 
   it "should encode the contact's middle name" do
     @contact.name.middle = "Quentin"
-    @adapter.encode(@contact).should include("N:;;Quentin;;")
+    expect(@adapter.encode(@contact)).to include("N:;;Quentin;;")
   end
 
   it "should encode the contact's name prefix" do
     @contact.name.prefix = "Mr."
-    @adapter.encode(@contact).should include("N:;;;Mr.;")
+    expect(@adapter.encode(@contact)).to include("N:;;;Mr.;")
   end
 
   it "should encode the contact's name suffix" do
     @contact.name.suffix = "BSc"
-    @adapter.encode(@contact).should include("N:;;;;BSc")
+    expect(@adapter.encode(@contact)).to include("N:;;;;BSc")
   end
 
   it "should encode the contact's email address" do
     @contact.email_addresses << Ppl::Entity::EmailAddress.new("john@example.org")
-    @adapter.encode(@contact).should include("EMAIL:john@example.org")
+    expect(@adapter.encode(@contact)).to include("EMAIL:john@example.org")
   end
 
   it "should encode the contact's preferred email address as such" do
     email_address = Ppl::Entity::EmailAddress.new("john@example.org")
     email_address.preferred = true
     @contact.email_addresses << email_address
-    @adapter.encode(@contact).should include("EMAIL;TYPE=pref:john@example.org")
+    expect(@adapter.encode(@contact)).to include("EMAIL;TYPE=pref:john@example.org")
   end
 
   it "should encode the contact's phone number" do
     @contact.phone_numbers << Ppl::Entity::PhoneNumber.new("01234567890")
-    @adapter.encode(@contact).should include("TEL:01234567890")
+    expect(@adapter.encode(@contact)).to include("TEL:01234567890")
   end
 
   it "should encode the contact's preferred phone number as such" do
     @contact.phone_numbers << Ppl::Entity::PhoneNumber.new("01234567890")
     @contact.phone_numbers[0].preferred = true
-    @adapter.encode(@contact).should include("TEL;TYPE=pref:01234567890")
+    expect(@adapter.encode(@contact)).to include("TEL;TYPE=pref:01234567890")
   end
 
   it "should encode the contact's phone number's type" do
     @contact.phone_numbers << Ppl::Entity::PhoneNumber.new("01234567890", "cell")
-    @adapter.encode(@contact).should include("TEL;TYPE=cell:01234567890")
+    expect(@adapter.encode(@contact)).to include("TEL;TYPE=cell:01234567890")
   end
 
   it "should encode the contact's organization" do
     @contact.organizations.push("Example Ltd")
-    @adapter.encode(@contact).should include("ORG:Example Ltd")
+    expect(@adapter.encode(@contact)).to include("ORG:Example Ltd")
   end
 
   describe "postal address encoding" do
@@ -86,54 +86,54 @@ describe Ppl::Adapter::Vcard::Vpim, "#encode" do
 
     it "should encode the address id" do
       @contact.postal_addresses[0].id = "home"
-      @adapter.encode(@contact).should include("ADR;TYPE=home:;;;;;;")
+      expect(@adapter.encode(@contact)).to include("ADR;TYPE=home:;;;;;;")
     end
 
     it "should encode the preferred status of the address" do
       @contact.postal_addresses[0].preferred = true
-      @adapter.encode(@contact).should include("ADR;TYPE=pref:;;;;;;")
+      expect(@adapter.encode(@contact)).to include("ADR;TYPE=pref:;;;;;;")
     end
 
     it "should encode the contact's street address" do
       @contact.postal_addresses[0].street = "1 Testing Road"
-      @adapter.encode(@contact).should include("ADR:;;1 Testing Road;;;;")
+      expect(@adapter.encode(@contact)).to include("ADR:;;1 Testing Road;;;;")
     end
 
     it "should encode the contact's postal code" do
       @contact.postal_addresses[0].postal_code = "L7 8AA"
-      @adapter.encode(@contact).should include("ADR:;;;;;L7 8AA;")
+      expect(@adapter.encode(@contact)).to include("ADR:;;;;;L7 8AA;")
     end
 
     it "should encode the contact's po box" do
       @contact.postal_addresses[0].po_box = "123456"
-      @adapter.encode(@contact).should include("ADR:123456;;;;;;")
+      expect(@adapter.encode(@contact)).to include("ADR:123456;;;;;;")
     end
 
     it "should encode the contact's locality" do
       @contact.postal_addresses[0].locality = "Liverpool"
-      @adapter.encode(@contact).should include("ADR:;;;Liverpool;;;")
+      expect(@adapter.encode(@contact)).to include("ADR:;;;Liverpool;;;")
     end
 
     it "should encode the contact's country" do
       @contact.postal_addresses[0].country = "UK"
-      @adapter.encode(@contact).should include("ADR:;;;;;;UK")
+      expect(@adapter.encode(@contact)).to include("ADR:;;;;;;UK")
     end
 
     it "should encode the contact's region" do
       @contact.postal_addresses[0].region = "South West"
-      @adapter.encode(@contact).should include("ADR:;;;;South West;;")
+      expect(@adapter.encode(@contact)).to include("ADR:;;;;South West;;")
     end
 
   end
 
   it "should encode the contact's URL" do
     @contact.urls.push "http://google.com"
-    @adapter.encode(@contact).should include("URL:http://google.com")
+    expect(@adapter.encode(@contact)).to include("URL:http://google.com")
   end
 
   it "should encode the contact's nickname" do
     @contact.nicknames.push "Sleepy"
-    @adapter.encode(@contact).should include("NICKNAME:Sleepy")
+    expect(@adapter.encode(@contact)).to include("NICKNAME:Sleepy")
   end
 
 end
@@ -152,7 +152,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "N:,test",
       "END:VCARD",
     ].join("\n")
-    @adapter.decode(vcard).should be_a(Ppl::Entity::Contact)
+    expect(@adapter.decode(vcard)).to be_a(Ppl::Entity::Contact)
   end
 
   it "should decode the contact's birthday" do
@@ -163,7 +163,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "BDAY:20120102",
       "END:VCARD",
     ].join("\n")
-    @adapter.decode(vcard).birthday.strftime('%Y-%m-%d').should eq "2012-01-02"
+    expect(@adapter.decode(vcard).birthday.strftime('%Y-%m-%d')).to eq "2012-01-02"
   end
 
   it "should decode the contact's name" do
@@ -177,7 +177,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
     ].join("\n")
     contact = @adapter.decode(vcard)
 
-    contact.name.full.should eq "John Doe"
+    expect(contact.name.full).to eq "John Doe"
   end
 
   it "should decode the contact's email address" do
@@ -189,7 +189,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "END:VCARD",
     ].join("\n")
     contact = @adapter.decode(vcard)
-    contact.email_addresses.first.address.should eq "home@example.org"
+    expect(contact.email_addresses.first.address).to eq "home@example.org"
   end
 
   it "should mark preferred email addresses as such" do
@@ -201,7 +201,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "END:VCARD",
     ].join("\n")
     contact = @adapter.decode(vcard)
-    contact.email_addresses.first.preferred.should eq true
+    expect(contact.email_addresses.first.preferred).to eq true
   end
 
   it "should decode the contact's phone number" do
@@ -214,7 +214,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
     ].join("\n")
     contact = @adapter.decode(vcard)
     phone_number = contact.phone_numbers.first
-    phone_number.number.should eq "01234567890"
+    expect(phone_number.number).to eq "01234567890"
   end
 
   it "should mark preferred phone numbers as such" do
@@ -227,7 +227,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
     ].join("\n")
     contact = @adapter.decode(vcard)
     phone_number = contact.phone_numbers.first
-    phone_number.preferred.should eq true
+    expect(phone_number.preferred).to eq true
   end
 
   it "should decode the contact's phone number's type" do
@@ -240,7 +240,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
     ].join("\n")
     contact = @adapter.decode(vcard)
     phone_number = contact.phone_numbers.first
-    phone_number.type.should eq "cell"
+    expect(phone_number.type).to eq "cell"
   end
 
   it "should decode the contact's phone number's nonstandard type" do
@@ -253,7 +253,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
     ].join("\n")
     contact = @adapter.decode(vcard)
     phone_number = contact.phone_numbers.first
-    phone_number.type.should eq "testing"
+    expect(phone_number.type).to eq "testing"
   end
 
   it "should decode the contact's organization" do
@@ -265,7 +265,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "END:VCARD",
     ].join("\n")
     contact = @adapter.decode(vcard)
-    contact.organizations.first.should eq "Example Ltd"
+    expect(contact.organizations.first).to eq "Example Ltd"
   end
 
   describe "postal address decoding" do
@@ -279,7 +279,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].id.should eq "home"
+      expect(contact.postal_addresses[0].id).to eq "home"
     end
 
     it "should decode the postal address' ID even if it's a nonstandard type" do
@@ -291,7 +291,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].id.should eq "nasa"
+      expect(contact.postal_addresses[0].id).to eq "nasa"
     end
 
     it "should assign the postal address a fallback ID if necessary" do
@@ -303,7 +303,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].id.should eq "910c67f"
+      expect(contact.postal_addresses[0].id).to eq "910c67f"
     end
 
     it "should decode the contact's street address" do
@@ -315,7 +315,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].street.should eq "1 Testing Road"
+      expect(contact.postal_addresses[0].street).to eq "1 Testing Road"
     end
 
     it "should decode the contact's postal code" do
@@ -327,7 +327,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].postal_code.should eq "L7 8AA"
+      expect(contact.postal_addresses[0].postal_code).to eq "L7 8AA"
     end
 
     it "should decode the contact's po box" do
@@ -339,7 +339,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].po_box.should eq "123456"
+      expect(contact.postal_addresses[0].po_box).to eq "123456"
     end
 
     it "should decode the contact's locality" do
@@ -351,7 +351,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].locality.should eq "Liverpool"
+      expect(contact.postal_addresses[0].locality).to eq "Liverpool"
     end
 
     it "should decode the contact's region" do
@@ -363,7 +363,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].region.should eq "South West"
+      expect(contact.postal_addresses[0].region).to eq "South West"
     end
 
     it "should decode the contact's country" do
@@ -375,7 +375,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
         "END:VCARD",
       ].join("\n")
       contact = @adapter.decode(vcard)
-      contact.postal_addresses[0].country.should eq "UK"
+      expect(contact.postal_addresses[0].country).to eq "UK"
     end
 
   end
@@ -389,7 +389,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "END:VCARD",
     ].join("\n")
     contact = @adapter.decode(vcard)
-    contact.urls.first.should eq "http://google.com"
+    expect(contact.urls.first).to eq "http://google.com"
   end
 
   it "should decode the contact's nickame" do
@@ -401,7 +401,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "END:VCARD",
     ].join("\n")
     contact = @adapter.decode(vcard)
-    contact.nicknames.first.should eq "Happy"
+    expect(contact.nicknames.first).to eq "Happy"
   end
 
   it "should not choke on utf8" do
@@ -413,7 +413,7 @@ describe Ppl::Adapter::Vcard::Vpim, "#decode" do
       "END:VCARD",
     ].join("\n")
     contact = @adapter.decode(vcard)
-    contact.name.full.should eq "Straße"
+    expect(contact.name.full).to eq "Straße"
   end
 
 end

data/spec/ppl/adapter/vcard_spec.rb

@@ -1,4 +1,3 @@
-
 describe Ppl::Adapter::Vcard, "#encode" do
 
   describe "#encode" do

data/spec/ppl/application/bootstrap_spec.rb

@@ -1,4 +1,3 @@
-
 describe Ppl::Application::Bootstrap do
 
   before(:each) do
@@ -7,30 +6,30 @@ describe Ppl::Application::Bootstrap do
 
   describe "#command_add" do
     it "should return a Ppl::Command::Add" do
-      @bootstrap.command_add.should be_a(Ppl::Command::Add)
+      expect(@bootstrap.command_add).to be_a(Ppl::Command::Add)
     end
   end
 
   describe "#command_age" do
     it "should return a Ppl::Command::Age" do
-      @bootstrap.command_age.should be_a(Ppl::Command::Age)
+      expect(@bootstrap.command_age).to be_a(Ppl::Command::Age)
     end
   end
 
   describe "#command_bday" do
     it "should return a Ppl::Command::Bday" do
-      @bootstrap.command_bday.should be_a(Ppl::Command::Bday)
+      expect(@bootstrap.command_bday).to be_a(Ppl::Command::Bday)
     end
   end
 
   describe "#command_completion" do
     it "should return a Ppl::Command::Completion" do
-      @bootstrap.command_completion.should be_a(Ppl::Command::Completion)
+      expect(@bootstrap.command_completion).to be_a(Ppl::Command::Completion)
     end
     it "should inject a completions directory" do
-      Ppl::Command::Completion.stub(:new) do
+      allow(Ppl::Command::Completion).to receive(:new) do
         completion = double(Ppl::Command::Completion)
-        completion.should_receive(:completions_directory=)
+        expect(completion).to receive(:completions_directory=)
         completion
       end
       @bootstrap.command_completion
@@ -39,141 +38,141 @@ describe Ppl::Application::Bootstrap do
 
   describe "#command_email" do
     it "should return a Ppl::Command::Email" do
-      @bootstrap.command_email.should be_a(Ppl::Command::Email)
+      expect(@bootstrap.command_email).to be_a(Ppl::Command::Email)
     end
   end
 
   describe "#command_grep" do
     it "should return a command" do
-      @bootstrap.command_grep.should be_a(Ppl::Application::Command)
+      expect(@bootstrap.command_grep).to be_a(Ppl::Application::Command)
     end
   end
 
   describe "#command_help" do
     it "should return a Ppl::Command::Help" do
-      @bootstrap.command_help.should be_a(Ppl::Command::Help)
+      expect(@bootstrap.command_help).to be_a(Ppl::Command::Help)
     end
   end
 
   describe "#command_init" do
     it "should return a Ppl::Command::Init" do
-      @bootstrap.command_init.should be_a(Ppl::Command::Init)
+      expect(@bootstrap.command_init).to be_a(Ppl::Command::Init)
     end
   end
 
   describe "#command_ls" do
     it "should return a Ppl::Command::Ls" do
-      @bootstrap.command_ls.should be_a(Ppl::Command::Ls)
+      expect(@bootstrap.command_ls).to be_a(Ppl::Command::Ls)
     end
   end
 
   describe "#command_mutt" do
     it "should return a Ppl::Command::Mutt" do
-      @bootstrap.command_mutt.should be_a(Ppl::Command::Mutt)
+      expect(@bootstrap.command_mutt).to be_a(Ppl::Command::Mutt)
     end
   end
 
   describe "#command_mv" do
     it "should return a Ppl::Command::Mv" do
-      @bootstrap.command_mv.should be_a(Ppl::Command::Mv)
+      expect(@bootstrap.command_mv).to be_a(Ppl::Command::Mv)
     end
   end
 
   describe "#command_name" do
     it "should return a Ppl::Command::Name" do
-      @bootstrap.command_name.should be_a(Ppl::Command::Name)
+      expect(@bootstrap.command_name).to be_a(Ppl::Command::Name)
     end
   end
 
   describe "#command_nick" do
     it "should return a Ppl::Command::Nick" do
-      @bootstrap.command_nick.should be_a(Ppl::Command::Nick)
+      expect(@bootstrap.command_nick).to be_a(Ppl::Command::Nick)
     end
   end
 
   describe "#command_org" do
     it "should return a Ppl::Command::Org" do
-      @bootstrap.command_org.should be_a(Ppl::Command::Org)
+      expect(@bootstrap.command_org).to be_a(Ppl::Command::Org)
     end
   end
 
   describe "#command_phone" do
     it "should return a Ppl::Command::Phone" do
-      @bootstrap.command_phone.should be_a(Ppl::Command::Phone)
+      expect(@bootstrap.command_phone).to be_a(Ppl::Command::Phone)
     end
   end
 
   describe "#command_post" do
     it "should return a Ppl::Command::Post" do
-      @bootstrap.command_post.should be_a(Ppl::Command::Post)
+      expect(@bootstrap.command_post).to be_a(Ppl::Command::Post)
     end
   end
 
   describe "#command_pull" do
     it "should return a command" do
-      @bootstrap.command_pull.should be_a(Ppl::Application::Command)
+      expect(@bootstrap.command_pull).to be_a(Ppl::Application::Command)
     end
   end
 
   describe "#command_push" do
     it "should return a command" do
-      @bootstrap.command_push.should be_a(Ppl::Application::Command)
+      expect(@bootstrap.command_push).to be_a(Ppl::Application::Command)
     end
   end
 
   describe "#command_remote" do
     it "should return a command" do
-      @bootstrap.command_remote.should be_a(Ppl::Application::Command)
+      expect(@bootstrap.command_remote).to be_a(Ppl::Application::Command)
     end
   end
 
   describe "#command_rm" do
     it "should return a Ppl::Command::Rm" do
-      @bootstrap.command_rm.should be_a(Ppl::Command::Rm)
+      expect(@bootstrap.command_rm).to be_a(Ppl::Command::Rm)
     end
   end
 
   describe "#command_scrape" do
     it "should return a Ppl::Command::Scrape" do
-      @bootstrap.command_scrape.should be_a(Ppl::Command::Scrape)
+      expect(@bootstrap.command_scrape).to be_a(Ppl::Command::Scrape)
     end
   end
 
   describe "#command_shell" do
     it "should return a Ppl::Command::Shell" do
-      @bootstrap.command_shell.should be_a(Ppl::Command::Shell)
+      expect(@bootstrap.command_shell).to be_a(Ppl::Command::Shell)
     end
   end
 
   describe "#command_show" do
     it "should return a Ppl::Command::Show" do
-      @bootstrap.command_show.should be_a(Ppl::Command::Show)
+      expect(@bootstrap.command_show).to be_a(Ppl::Command::Show)
     end
   end
 
   describe "#command_url" do
     it "should return a Ppl::Command::Url" do
-      @bootstrap.command_url.should be_a(Ppl::Command::Url)
+      expect(@bootstrap.command_url).to be_a(Ppl::Command::Url)
     end
   end
 
   describe "#command_version" do
     it "should return a Ppl::Command::Version" do
-      @bootstrap.command_version.should be_a(Ppl::Command::Version)
+      expect(@bootstrap.command_version).to be_a(Ppl::Command::Version)
     end
   end
 
   describe "#format_address_book_ages" do
 
     it "should return a Ppl::Format::AddressBook::Ages" do
-      @bootstrap.format_address_book_ages.should be_a(Ppl::Format::AddressBook::Ages)
+      expect(@bootstrap.format_address_book_ages).to be_a(Ppl::Format::AddressBook::Ages)
     end
 
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("age").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("age").and_return(@colors)
       @bootstrap.format_address_book_ages
     end
 
@@ -181,369 +180,369 @@ describe Ppl::Application::Bootstrap do
 
   describe "#format_address_book_birthdays" do
     it "should return a Ppl::Format::AddressBook::Birthdays" do
-      @bootstrap.format_address_book_birthdays.should be_a(Ppl::Format::AddressBook::Birthdays)
+      expect(@bootstrap.format_address_book_birthdays).to be_a(Ppl::Format::AddressBook::Birthdays)
     end
 
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("bday").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("bday").and_return(@colors)
       @bootstrap.format_address_book_birthdays
     end
   end
 
   describe "#format_address_book_email_addresses" do
     it "should return a Ppl::Format::AddressBook::EmailAddresses" do
-      @bootstrap.format_address_book_email_addresses.should be_a(Ppl::Format::AddressBook::EmailAddresses)
+      expect(@bootstrap.format_address_book_email_addresses).to be_a(Ppl::Format::AddressBook::EmailAddresses)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("email").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("email").and_return(@colors)
       @bootstrap.format_address_book_email_addresses
     end
   end
 
   describe "#format_address_book_mutt_query" do
     it "should return a Ppl::Format::AddressBook::MuttQuery" do
-      @bootstrap.format_address_book_mutt_query.should be_a(Ppl::Format::AddressBook::MuttQuery)
+      expect(@bootstrap.format_address_book_mutt_query).to be_a(Ppl::Format::AddressBook::MuttQuery)
     end
   end
 
   describe "#format_address_book_organizations" do
     it "should return a Ppl::Format::AddressBook::Organizations" do
-      @bootstrap.format_address_book_organizations.should be_a(Ppl::Format::AddressBook::Organizations)
+      expect(@bootstrap.format_address_book_organizations).to be_a(Ppl::Format::AddressBook::Organizations)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("org").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("org").and_return(@colors)
       @bootstrap.format_address_book_organizations
     end
   end
 
   describe "#format_address_book_names" do
     it "should return a Ppl::Format::AddressBook::Names" do
-      @bootstrap.format_address_book_names.should be_a(Ppl::Format::AddressBook::Names)
+      expect(@bootstrap.format_address_book_names).to be_a(Ppl::Format::AddressBook::Names)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("name").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("name").and_return(@colors)
       @bootstrap.format_address_book_names
     end
   end
 
   describe "#format_address_book_nicknames" do
     it "should return a Ppl::Format::AddressBook::Nicknames" do
-      @bootstrap.format_address_book_nicknames.should be_a(Ppl::Format::AddressBook::Nicknames)
+      expect(@bootstrap.format_address_book_nicknames).to be_a(Ppl::Format::AddressBook::Nicknames)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("nick").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("nick").and_return(@colors)
       @bootstrap.format_address_book_nicknames
     end
   end
 
   describe "#format_address_book_one_line" do
     it "should return a Ppl::Format::AddressBook::OneLine" do
-      @bootstrap.format_address_book_one_line.should be_a(Ppl::Format::AddressBook::OneLine)
+      expect(@bootstrap.format_address_book_one_line).to be_a(Ppl::Format::AddressBook::OneLine)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("ls").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("ls").and_return(@colors)
       @bootstrap.format_address_book_one_line
     end
   end
 
   describe "#format_address_book_phone_numbers" do
     it "should return a Ppl::Format::Address_book::PhoneNumbers" do
-      @bootstrap.format_address_book_phone_numbers.should be_a(Ppl::Format::AddressBook::PhoneNumbers)
+      expect(@bootstrap.format_address_book_phone_numbers).to be_a(Ppl::Format::AddressBook::PhoneNumbers)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("phone").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("phone").and_return(@colors)
       @bootstrap.format_address_book_phone_numbers
     end
   end
 
   describe "#format_address_book_postal_addresses" do
     it "should return a Ppl::Format::AddressBook::PostalAddresses" do
-      @bootstrap.format_address_book_postal_addresses.should be_a(Ppl::Format::AddressBook::PostalAddresses)
+      expect(@bootstrap.format_address_book_postal_addresses).to be_a(Ppl::Format::AddressBook::PostalAddresses)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("post").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("post").and_return(@colors)
       @bootstrap.format_address_book_postal_addresses
     end
   end
 
   describe "#format_address_book_urls" do
     it "should return a Ppl::Format::AddressBook::Urls" do
-      @bootstrap.format_address_book_urls.should be_a(Ppl::Format::AddressBook::Urls)
+      expect(@bootstrap.format_address_book_urls).to be_a(Ppl::Format::AddressBook::Urls)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("url").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("url").and_return(@colors)
       @bootstrap.format_address_book_urls
     end
   end
 
   describe "#format_contact_age" do
     it "should return a Ppl::Format::Contact::Age" do
-      @bootstrap.format_contact_age.should be_a(Ppl::Format::Contact::Age)
+      expect(@bootstrap.format_contact_age).to be_a(Ppl::Format::Contact::Age)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("age").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("age").and_return(@colors)
       @bootstrap.format_contact_age
     end
   end
 
   describe "#format_contact_birthday" do
     it "should return a Ppl::Format::Contact::Birthday" do
-      @bootstrap.format_contact_birthday.should be_a(Ppl::Format::Contact::Birthday)
+      expect(@bootstrap.format_contact_birthday).to be_a(Ppl::Format::Contact::Birthday)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("bday").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("bday").and_return(@colors)
       @bootstrap.format_contact_birthday
     end
   end
 
   describe "#format_contact_email_addresses" do
     it "should return a Ppl::Format::Contact::EmailAddresses" do
-      @bootstrap.format_contact_email_addresses.should be_a(Ppl::Format::Contact::EmailAddresses)
+      expect(@bootstrap.format_contact_email_addresses).to be_a(Ppl::Format::Contact::EmailAddresses)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("email").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("email").and_return(@colors)
       @bootstrap.format_contact_email_addresses
     end
   end
 
   describe "#format_name_full_only" do
     it "should return a Ppl::Format::Contact::Name" do
-      @bootstrap.format_name_full_only.should be_a(Ppl::Format::Name::FullOnly)
+      expect(@bootstrap.format_name_full_only).to be_a(Ppl::Format::Name::FullOnly)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("name").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("name").and_return(@colors)
       @bootstrap.format_name_full_only
     end
   end
 
   describe "#format_contact_nicknames" do
     it "should return a Ppl::Format::Contact::Nicknames" do
-      @bootstrap.format_contact_nicknames.should be_a(Ppl::Format::Contact::Nicknames)
+      expect(@bootstrap.format_contact_nicknames).to be_a(Ppl::Format::Contact::Nicknames)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("nick").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("nick").and_return(@colors)
       @bootstrap.format_contact_nicknames
     end
   end
 
   describe "#format_contact_organizations" do
     it "should return a Ppl::Format::Contact::Organizations" do
-      @bootstrap.format_contact_organizations.should be_a(Ppl::Format::Contact::Organization)
+      expect(@bootstrap.format_contact_organizations).to be_a(Ppl::Format::Contact::Organization)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("org").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("org").and_return(@colors)
       @bootstrap.format_contact_organizations
     end
   end
 
   describe "#format_contact_phone_numbers" do
     it "should return a Ppl::Format::Contact::PhoneNumber" do
-      @bootstrap.format_contact_phone_numbers.should be_a(Ppl::Format::Contact::PhoneNumber)
+      expect(@bootstrap.format_contact_phone_numbers).to be_a(Ppl::Format::Contact::PhoneNumber)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("phone").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("phone").and_return(@colors)
       @bootstrap.format_contact_phone_numbers
     end
   end
 
   describe "#format_contact_postal_addresses" do
     it "should return a Ppl::Format::Contact::PostalAddresses" do
-      @bootstrap.format_contact_postal_addresses.should be_a(Ppl::Format::Contact::PostalAddresses)
+      expect(@bootstrap.format_contact_postal_addresses).to be_a(Ppl::Format::Contact::PostalAddresses)
     end
   end
 
   describe "#format_contact_urls" do
     it "should return a Ppl::Format::Contact::Urls" do
-      @bootstrap.format_contact_urls.should be_a(Ppl::Format::Contact::Urls)
+      expect(@bootstrap.format_contact_urls).to be_a(Ppl::Format::Contact::Urls)
     end
     it "should set up colored output if configured to do so" do
       @colors = {}
       @config = double(Ppl::Application::Configuration)
-      @bootstrap.stub(:configuration).and_return(@config)
-      @config.should_receive(:command_colors).with("url").and_return(@colors)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      expect(@config).to receive(:command_colors).with("url").and_return(@colors)
       @bootstrap.format_contact_urls
     end
   end
 
   describe "#format_postal_address_multi_line" do
     it "should return a Ppl::Format::PostalAddress::MultiLine" do
-      @bootstrap.format_postal_address_multi_line.should be_a(Ppl::Format::PostalAddress::MultiLine)
+      expect(@bootstrap.format_postal_address_multi_line).to be_a(Ppl::Format::PostalAddress::MultiLine)
     end
   end
 
   describe "#command_suite" do
 
     before(:each) do
-      @bootstrap.stub(:storage_adapter)
+      allow(@bootstrap).to receive(:storage_adapter)
     end
 
     it "should return a Ppl::Application::CommandSuite" do
-      @bootstrap.command_suite.should be_a(Ppl::Application::CommandSuite)
+      expect(@bootstrap.command_suite).to be_a(Ppl::Application::CommandSuite)
     end
     it "should contain the 'add' command" do
-      @bootstrap.command_suite.find_command("add").should_not be nil
+      expect(@bootstrap.command_suite.find_command("add")).not_to be nil
     end
     it "should contain the 'age' command" do
-      @bootstrap.command_suite.find_command("age").should_not be nil
+      expect(@bootstrap.command_suite.find_command("age")).not_to be nil
     end
     it "should contain the 'bday' command" do
-      @bootstrap.command_suite.find_command("bday").should_not be nil
+      expect(@bootstrap.command_suite.find_command("bday")).not_to be nil
     end
     it "should contain the 'completion' command" do
-      @bootstrap.command_suite.find_command("completion").should_not be nil
+      expect(@bootstrap.command_suite.find_command("completion")).not_to be nil
     end
     it "should contain the 'email' command" do
-      @bootstrap.command_suite.find_command("email").should_not be nil
+      expect(@bootstrap.command_suite.find_command("email")).not_to be nil
     end
     it "should contain the 'grep' command" do
-      @bootstrap.command_suite.find_command("grep").should_not be nil
+      expect(@bootstrap.command_suite.find_command("grep")).not_to be nil
     end
     it "should contain the 'init' command" do
-      @bootstrap.command_suite.find_command("init").should_not be nil
+      expect(@bootstrap.command_suite.find_command("init")).not_to be nil
     end
     it "should contain the 'ls' command" do
-      @bootstrap.command_suite.find_command("ls").should_not be nil
+      expect(@bootstrap.command_suite.find_command("ls")).not_to be nil
     end
     it "should contain the 'mutt' command" do
-      @bootstrap.command_suite.find_command("mutt").should_not be nil
+      expect(@bootstrap.command_suite.find_command("mutt")).not_to be nil
     end
     it "should contain the 'mv' command" do
-      @bootstrap.command_suite.find_command("mv").should_not be nil
+      expect(@bootstrap.command_suite.find_command("mv")).not_to be nil
     end
     it "should contain the 'name' command" do
-      @bootstrap.command_suite.find_command("name").should_not be nil
+      expect(@bootstrap.command_suite.find_command("name")).not_to be nil
     end
     it "should contain the 'nick' command" do
-      @bootstrap.command_suite.find_command("nick").should_not be nil
+      expect(@bootstrap.command_suite.find_command("nick")).not_to be nil
     end
     it "should contain the 'org' command" do
-      @bootstrap.command_suite.find_command("org").should_not be nil
+      expect(@bootstrap.command_suite.find_command("org")).not_to be nil
     end
     it "should contain the 'phone' command" do
-      @bootstrap.command_suite.find_command("phone").should_not be nil
+      expect(@bootstrap.command_suite.find_command("phone")).not_to be nil
     end
     it "should contain the 'post' command" do
-      @bootstrap.command_suite.find_command("post").should_not be nil
+      expect(@bootstrap.command_suite.find_command("post")).not_to be nil
     end
     it "should contain the 'pull' command" do
-      @bootstrap.command_suite.find_command("pull").should_not be nil
+      expect(@bootstrap.command_suite.find_command("pull")).not_to be nil
     end
     it "should contain the 'push' command" do
-      @bootstrap.command_suite.find_command("push").should_not be nil
+      expect(@bootstrap.command_suite.find_command("push")).not_to be nil
     end
     it "should contain the 'remote' command" do
-      @bootstrap.command_suite.find_command("remote").should_not be nil
+      expect(@bootstrap.command_suite.find_command("remote")).not_to be nil
     end
     it "should contain the 'rm' command" do
-      @bootstrap.command_suite.find_command("rm").should_not be nil
+      expect(@bootstrap.command_suite.find_command("rm")).not_to be nil
     end
     it "should contain the 'scrape' command" do
-      @bootstrap.command_suite.find_command("scrape").should_not be nil
+      expect(@bootstrap.command_suite.find_command("scrape")).not_to be nil
     end
     it "should contain the 'show' command" do
-      @bootstrap.command_suite.find_command("show").should_not be nil
+      expect(@bootstrap.command_suite.find_command("show")).not_to be nil
     end
     it "should contain the 'help' command" do
-      @bootstrap.command_suite.find_command("help").should_not be nil
+      expect(@bootstrap.command_suite.find_command("help")).not_to be nil
     end
     it "should contain the 'shell' command" do
-      @bootstrap.command_suite.find_command("shell").should_not be nil
+      expect(@bootstrap.command_suite.find_command("shell")).not_to be nil
     end
     it "should contain the 'url' command" do
-      @bootstrap.command_suite.find_command("url").should_not be nil
+      expect(@bootstrap.command_suite.find_command("url")).not_to be nil
     end
     it "should contain the 'version' command" do
-      @bootstrap.command_suite.find_command("version").should_not be nil
+      expect(@bootstrap.command_suite.find_command("version")).not_to be nil
     end
   end
 
   describe "#configuration" do
     it "should return a Ppl::Application::Configuration" do
-      @bootstrap.configuration.should be_a(Ppl::Application::Configuration)
+      expect(@bootstrap.configuration).to be_a(Ppl::Application::Configuration)
     end
   end
 
   describe "#input" do
     it "should return a Ppl::Application::Input" do
-      @bootstrap.input.should be_a(Ppl::Application::Input)
+      expect(@bootstrap.input).to be_a(Ppl::Application::Input)
     end
   end
 
   describe "#output" do
     it "should return a Ppl::Application::Output" do
-      @bootstrap.output.should be_a(Ppl::Application::Output)
+      expect(@bootstrap.output).to be_a(Ppl::Application::Output)
     end
   end
 
   describe "#router" do
     before(:each) do
-      @bootstrap.stub(:storage_adapter)
+      allow(@bootstrap).to receive(:storage_adapter)
     end
     it "should return a Ppl::Application::Router" do
-      @bootstrap.router.should be_a(Ppl::Application::Router)
+      expect(@bootstrap.router).to be_a(Ppl::Application::Router)
     end
     it "should set the 'help' command as the default" do
-      @bootstrap.router.default.should eq "help"
+      expect(@bootstrap.router.default).to eq "help"
     end
     it "should inject the user's aliases" do
-      @bootstrap.router.aliases.should be_a(Hash)
+      expect(@bootstrap.router.aliases).to be_a(Hash)
     end
   end
 
   describe "#shell" do
     before(:each) do
-      @bootstrap.stub(:storage_adapter)
+      allow(@bootstrap).to receive(:storage_adapter)
     end
     it "should return a Ppl::Application::Shell" do
-      @bootstrap.shell.should be_a(Ppl::Application::Shell)
+      expect(@bootstrap.shell).to be_a(Ppl::Application::Shell)
     end
   end
 
@@ -551,32 +550,32 @@ describe Ppl::Application::Bootstrap do
     before(:each) do
       @config  = double(Ppl::Application::Configuration)
       @factory = double(Ppl::Adapter::Storage::Factory)
-      @bootstrap.stub(:configuration).and_return(@config)
-      Ppl::Adapter::Storage::Factory.stub(:new).and_return(@factory)
+      allow(@bootstrap).to receive(:configuration).and_return(@config)
+      allow(Ppl::Adapter::Storage::Factory).to receive(:new).and_return(@factory)
 
-      @config.should_receive(:address_book_path).and_return("/tmp")
-      @factory.should_receive(:load_adapter).and_return(Ppl::Adapter::Storage::Disk.new(nil))
+      expect(@config).to receive(:address_book_path).and_return("/tmp")
+      expect(@factory).to receive(:load_adapter).and_return(Ppl::Adapter::Storage::Disk.new(nil))
     end
     it "should return a Ppl::Adapter::Storage" do
-      @bootstrap.storage_adapter.should be_a(Ppl::Adapter::Storage)
+      expect(@bootstrap.storage_adapter).to be_a(Ppl::Adapter::Storage)
     end
   end
 
   describe "#vcard_adapter" do
     it "should return a Ppl::Adapter::Vcard::Vpim" do
-      @bootstrap.vcard_adapter.should be_a(Ppl::Adapter::Vcard::Vpim)
+      expect(@bootstrap.vcard_adapter).to be_a(Ppl::Adapter::Vcard::Vpim)
     end
   end
 
   describe "#name_service" do
     it "should return a Ppl::Service::Name" do
-      @bootstrap.name_service.should be_a(Ppl::Service::Name)
+      expect(@bootstrap.name_service).to be_a(Ppl::Service::Name)
     end
   end
 
   describe "#postal_address_service" do
     it "should return a Ppl::Service::PostalAddress" do
-      @bootstrap.postal_address_service.should be_a(Ppl::Service::PostalAddress)
+      expect(@bootstrap.postal_address_service).to be_a(Ppl::Service::PostalAddress)
     end
   end