ppl 4.0.1 → 4.0.2

data/spec/ppl/command/mv_spec.rb

@@ -13,7 +13,7 @@ describe Ppl::Command::Mv do
 
   describe "#name" do
     it "should be 'mv'" do
-      @command.name.should eq "mv"
+      expect(@command.name).to eq "mv"
     end
   end
 
@@ -30,24 +30,24 @@ describe Ppl::Command::Mv do
     end
 
     it "should return false if the new id is taken" do
-      @storage.should_receive(:require_contact).with("old").and_return(@contact)
-      @storage.should_receive(:load_contact).with("new").and_return(@contact)
-      @output.should_receive(:error)
+      expect(@storage).to receive(:require_contact).with("old").and_return(@contact)
+      expect(@storage).to receive(:load_contact).with("new").and_return(@contact)
+      expect(@output).to receive(:error)
       @input.arguments = ["old", "new"]
 
-      @command.execute(@input, @output).should eq false
+      expect(@command.execute(@input, @output)).to eq false
     end
 
     it "should rename the given contact" do
-      @storage.should_receive(:require_contact).with("old").and_return(@contact)
-      @storage.should_receive(:load_contact).with("new").and_return(nil)
+      expect(@storage).to receive(:require_contact).with("old").and_return(@contact)
+      expect(@storage).to receive(:load_contact).with("new").and_return(nil)
 
-      @storage.should_receive(:delete_contact).with(@contact) do |contact|
-        contact.id.should eq "old"
+      expect(@storage).to receive(:delete_contact).with(@contact) do |contact|
+        expect(contact.id).to eq "old"
       end
 
-      @storage.should_receive(:save_contact).with(@contact) do |contact|
-        contact.id.should eq "new"
+      expect(@storage).to receive(:save_contact).with(@contact) do |contact|
+        expect(contact.id).to eq "new"
       end
 
       @input.arguments = ["old", "new"]

data/spec/ppl/command/name_spec.rb

@@ -24,51 +24,51 @@ describe Ppl::Command::Name do
 
   describe "#name" do
     it "should be 'name'" do
-      @command.name.should eq "name"
+      expect(@command.name).to eq "name"
     end
   end
 
   describe "#execute" do
 
     it "should list all contact names if no contact ID is given" do
-      @storage.should_receive(:load_address_book).and_return(@address_book)
-      @list_format.should_receive(:process).and_return("all the names")
-      @output.should_receive(:line).with("all the names")
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@list_format).to receive(:process).and_return("all the names")
+      expect(@output).to receive(:line).with("all the names")
       @input.arguments = []
       @command.execute(@input, @output)
     end
 
     it "should show the specified contact's name if no name is given" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @show_format.should_receive(:process).and_return("John Doe")
-      @output.should_receive(:line).with("John Doe")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@show_format).to receive(:process).and_return("John Doe")
+      expect(@output).to receive(:line).with("John Doe")
       @input.arguments = ["jim"]
-      @command.execute(@input, @output).should eq true
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should not output anything if there's nothing to show" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @show_format.should_receive(:process).and_return("")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@show_format).to receive(:process).and_return("")
       @input.arguments = ["jim"]
-      @command.execute(@input, @output).should eq false
+      expect(@command.execute(@input, @output)).to eq false
     end
 
     it "should change the contact's name if a name is given" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @name_service.should_receive(:update).with(@contact.name, {
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@name_service).to receive(:update).with(@contact.name, {
         :full => "Jim Jamieson"
       })
-      @storage.should_receive(:save_contact)
+      expect(@storage).to receive(:save_contact)
       @input.arguments = ["jim", "Jim Jamieson"]
       @command.execute(@input, @output)
     end
 
     it "should change the contact's name if a name is given" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @name_service.should_receive(:update).with(@contact.name, {
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@name_service).to receive(:update).with(@contact.name, {
         :family => "Smith"
       })
-      @storage.should_receive(:save_contact)
+      expect(@storage).to receive(:save_contact)
       @input.arguments = ["jim"]
       @input.options = { :family => "Smith" }
       @command.execute(@input, @output)

data/spec/ppl/command/nick_spec.rb

@@ -6,7 +6,7 @@ describe Ppl::Command::Nick do
 
   describe "#name" do
     it "should be 'nick'" do
-      @command.name.should eq "nick"
+      expect(@command.name).to eq "nick"
     end
   end
 

data/spec/ppl/command/org_spec.rb

@@ -6,7 +6,7 @@ describe Ppl::Command::Org do
 
   describe "#name" do
     it "should be 'org'" do
-      @command.name.should eq "org"
+      expect(@command.name).to eq "org"
     end
   end
 

data/spec/ppl/command/phone_spec.rb

@@ -6,7 +6,7 @@ describe Ppl::Command::Phone do
 
   describe "#name" do
     it "should be 'phone'" do
-      @command.name.should eq "phone"
+      expect(@command.name).to eq "phone"
     end
   end
 
@@ -20,8 +20,8 @@ describe Ppl::Command::Phone do
       @show_format = double(Ppl::Format::Contact)
       @input = Ppl::Application::Input.new
       @output = double(Ppl::Application::Output)
-      @storage.stub(:require_contact).and_return(@contact)
-      @storage.stub(:save_contact)
+      allow(@storage).to receive(:require_contact).and_return(@contact)
+      allow(@storage).to receive(:save_contact)
       @command.phone_service = @service
       @command.storage = @storage
       @command.list_format = @list_format
@@ -29,40 +29,40 @@ describe Ppl::Command::Phone do
     end
 
     it "should list all phone numbers by default" do
-      @storage.should_receive(:load_address_book).and_return(@address_book)
-      @list_format.should_receive(:process)
-      @output.should_receive(:line)
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@list_format).to receive(:process)
+      expect(@output).to receive(:line)
       @command.execute(@input, @output)
     end
 
     it "should show a single contact's numbers if one is specified" do
       @input.arguments << "jdoe"
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @show_format.should_receive(:process)
-      @output.should_receive(:line)
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@show_format).to receive(:process)
+      expect(@output).to receive(:line)
       @command.execute(@input, @output)
     end
 
     it "should delegate to the service layer to remove a phone number" do
       @input.arguments = ["jdoe", "01234567890"]
       @input.options[:delete] = true
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @service.should_receive(:remove).with(@contact, "01234567890")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@service).to receive(:remove).with(@contact, "01234567890")
       @command.execute(@input, @output)
     end
 
     it "should delegate to the service layer to add a new phone number" do
       @input.arguments = ["jdoe", "98776332"]
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @service.should_receive(:add).with(@contact, "98776332", @input.options)
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@service).to receive(:add).with(@contact, "98776332", @input.options)
       @command.execute(@input, @output)
     end
 
     it "should delegate to the service layer to update an existing number" do
       @contact.phone_numbers << Ppl::Entity::PhoneNumber.new("012345678")
       @input.arguments = ["jdoe", "012345678"]
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @service.should_receive(:update).with(@contact, "012345678", {})
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@service).to receive(:update).with(@contact, "012345678", {})
       @command.execute(@input, @output)
     end
 

data/spec/ppl/command/post_spec.rb

@@ -26,7 +26,7 @@ describe Ppl::Command::Post do
 
   describe "#name" do
     it "should be 'post'" do
-      @command.name.should eq "post"
+      expect(@command.name).to eq "post"
     end
   end
 
@@ -37,9 +37,9 @@ describe Ppl::Command::Post do
       before { @input.arguments = [] }
 
       it "displays postal address information for the whole address book" do
-        @storage.should_receive(:load_address_book).and_return(@address_book)
-        @address_book_format.should_receive(:process).and_return("all the postal addresses")
-        @output.should_receive(:line).with("all the postal addresses")
+        expect(@storage).to receive(:load_address_book).and_return(@address_book)
+        expect(@address_book_format).to receive(:process).and_return("all the postal addresses")
+        expect(@output).to receive(:line).with("all the postal addresses")
         @input.arguments = []
         @command.execute(@input, @output)
       end
@@ -50,16 +50,16 @@ describe Ppl::Command::Post do
       before { @input.arguments = ["jim"] }
 
       it "shows all of a contact's postal addresses" do
-        @storage.should_receive(:require_contact).and_return(@contact)
-        @contact_format.should_receive(:process).and_return("1 Test Road")
-        @output.should_receive(:line).with("1 Test Road")
-        @command.execute(@input, @output).should eq true
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect(@contact_format).to receive(:process).and_return("1 Test Road")
+        expect(@output).to receive(:line).with("1 Test Road")
+        expect(@command.execute(@input, @output)).to eq true
       end
 
       it "outputs nothing if the contact has no addresses" do
-        @storage.should_receive(:require_contact).and_return(@contact)
-        @contact_format.should_receive(:process).and_return("")
-        @command.execute(@input, @output).should eq false
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect(@contact_format).to receive(:process).and_return("")
+        expect(@command.execute(@input, @output)).to eq false
       end
 
     end
@@ -69,16 +69,16 @@ describe Ppl::Command::Post do
       before { @input.arguments = ["jim", "home"] }
 
       it "shows a single postal address" do
-        @storage.should_receive(:require_contact).and_return(@contact)
-        @postal_address_format.should_receive(:process).with(@address).and_return("1 Test Road")
-        @output.should_receive(:line).with("1 Test Road")
-        @command.execute(@input, @output).should eq true
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect(@postal_address_format).to receive(:process).with(@address).and_return("1 Test Road")
+        expect(@output).to receive(:line).with("1 Test Road")
+        expect(@command.execute(@input, @output)).to eq true
       end
 
       it "raises an error if there's no such address" do
         @input.arguments[1] = "other"
-        @storage.should_receive(:require_contact).and_return(@contact)
-        expect{@command.execute(@input, @output).should eq true}.to raise_error(Ppl::Error::PostalAddressNotFound)
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect{expect(@command.execute(@input, @output)).to eq true}.to raise_error(Ppl::Error::PostalAddressNotFound)
       end
 
     end
@@ -89,10 +89,10 @@ describe Ppl::Command::Post do
       before { @input.options = { :delete => true }}
 
       it "deletes the postal address" do
-        @storage.should_receive(:require_contact).and_return(@contact)
-        @service.should_receive(:remove).with(@contact, "home")
-        @storage.should_receive(:save_contact)
-        @command.execute(@input, @output).should eq true
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect(@service).to receive(:remove).with(@contact, "home")
+        expect(@storage).to receive(:save_contact)
+        expect(@command.execute(@input, @output)).to eq true
       end
 
     end
@@ -103,10 +103,10 @@ describe Ppl::Command::Post do
       before { @input.options = { :country => "New Country" }}
 
       it "updates the postal address" do
-        @storage.should_receive(:require_contact).and_return(@contact)
-        @service.should_receive(:update).with(@contact, "home", {:country => "New Country"})
-        @storage.should_receive(:save_contact)
-        @command.execute(@input, @output).should eq true
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect(@service).to receive(:update).with(@contact, "home", {:country => "New Country"})
+        expect(@storage).to receive(:save_contact)
+        expect(@command.execute(@input, @output)).to eq true
       end
 
     end
@@ -118,10 +118,10 @@ describe Ppl::Command::Post do
       before { @input.options = { :street => "123 Swim St" }}
 
       it "adds the postal address" do
-        @storage.should_receive(:require_contact).and_return(@contact)
-        @service.should_receive(:add).with(@contact, "newaddress", {:street => "123 Swim St"})
-        @storage.should_receive(:save_contact)
-        @command.execute(@input, @output).should eq true
+        expect(@storage).to receive(:require_contact).and_return(@contact)
+        expect(@service).to receive(:add).with(@contact, "newaddress", {:street => "123 Swim St"})
+        expect(@storage).to receive(:save_contact)
+        expect(@command.execute(@input, @output)).to eq true
       end
 
     end

data/spec/ppl/command/rm_spec.rb

@@ -13,7 +13,7 @@ describe Ppl::Command::Rm do
 
   describe "#name" do
     it "should be 'rm'" do
-      @command.name.should eq "rm"
+      expect(@command.name).to eq "rm"
     end
   end
 
@@ -25,8 +25,8 @@ describe Ppl::Command::Rm do
     end
 
     it "should delete the given contact" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @storage.should_receive(:delete_contact).with(@contact)
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@storage).to receive(:delete_contact).with(@contact)
       @command.execute(@input, @output)
     end
 

data/spec/ppl/command/scrape_spec.rb

@@ -15,68 +15,68 @@ describe Ppl::Command::Scrape do
 
   describe "#name" do
     it "should be 'scrape'" do
-      @command.name.should eq "scrape"
+      expect(@command.name).to eq "scrape"
     end
   end
 
   describe "#execute" do
 
     before(:each) do
-      @input.stdin.stub(:read)
-      @input.stdin.stub(:reopen)
-      @input.stdin.stub(:eof?)
-      @email_scraper.stub(:scrape_contacts).and_return([])
-      Readline.stub(:readline).and_return("")
-      @storage.stub(:save_contact)
+      allow(@input.stdin).to receive(:read)
+      allow(@input.stdin).to receive(:reopen)
+      allow(@input.stdin).to receive(:eof?)
+      allow(@email_scraper).to receive(:scrape_contacts).and_return([])
+      allow(Readline).to receive(:readline).and_return("")
+      allow(@storage).to receive(:save_contact)
     end
 
     it "should read input from stdin" do
       @input.options[:sender] = true
-      @input.stdin.should_receive(:read)
+      expect(@input.stdin).to receive(:read)
       @command.execute(@input, @output)
     end
 
     it "should pass input to the email scraper" do
       @input.options[:sender] = true
-      @email_scraper.should_receive(:scrape_contacts)
+      expect(@email_scraper).to receive(:scrape_contacts)
       @command.execute(@input, @output)
     end
 
     it "shouldn't do any scraping unless told which fields to scrape" do
-      @email_scraper.should_not_receive(:scrape_contacts)
+      expect(@email_scraper).not_to receive(:scrape_contacts)
       @command.execute(@input, @output)
     end
 
     it "should always save contacts if in quiet mode" do
       @input.options[:sender] = true
       @input.options[:quiet] = true
-      @email_scraper.stub(:scrape_contacts).and_return([@contact])
-      Readline.should_not_receive(:readline)
-      @storage.should_receive(:save_contact)
+      allow(@email_scraper).to receive(:scrape_contacts).and_return([@contact])
+      expect(Readline).not_to receive(:readline)
+      expect(@storage).to receive(:save_contact)
       @command.execute(@input, @output)
     end
 
     it "should reopen stdin to prompt the user" do
       @input.options[:sender] = true
-      @input.stdin.should_receive(:eof?).and_return(true)
-      @input.stdin.should_receive(:reopen)
-      @email_scraper.stub(:scrape_contacts).and_return([@contact])
+      expect(@input.stdin).to receive(:eof?).and_return(true)
+      expect(@input.stdin).to receive(:reopen)
+      allow(@email_scraper).to receive(:scrape_contacts).and_return([@contact])
       @command.execute(@input, @output)
     end
 
     it "should save the contact if the user approves" do
       @input.options[:sender] = true
-      @email_scraper.stub(:scrape_contacts).and_return([@contact])
-      Readline.should_receive(:readline).and_return("y")
-      @storage.should_receive(:save_contact)
+      allow(@email_scraper).to receive(:scrape_contacts).and_return([@contact])
+      expect(Readline).to receive(:readline).and_return("y")
+      expect(@storage).to receive(:save_contact)
       @command.execute(@input, @output)
     end
 
     it "should not save the contact if the user disapproves" do
       @input.options[:sender] = true
-      @email_scraper.stub(:scrape_contacts).and_return([@contact])
-      Readline.should_receive(:readline).and_return("n")
-      @storage.should_not_receive(:save_contact)
+      allow(@email_scraper).to receive(:scrape_contacts).and_return([@contact])
+      expect(Readline).to receive(:readline).and_return("n")
+      expect(@storage).not_to receive(:save_contact)
       @command.execute(@input, @output)
     end
 
@@ -85,8 +85,8 @@ describe Ppl::Command::Scrape do
       contact = Ppl::Entity::Contact.new
       contact.name = "Test Person"
       contact.email_addresses << "test@example.org"
-      @email_scraper.stub(:scrape_contacts).and_return([contact])
-      Readline.should_receive(:readline).with("Add \"Test Person <test@example.org>\" to your address book [Y/n]? ")
+      allow(@email_scraper).to receive(:scrape_contacts).and_return([contact])
+      expect(Readline).to receive(:readline).with("Add \"Test Person <test@example.org>\" to your address book [Y/n]? ")
       @command.execute(@input, @output)
     end
 

data/spec/ppl/command/shell_spec.rb

@@ -8,16 +8,16 @@ describe Ppl::Command::Shell do
 
   describe "#name" do
     it "should be 'shell'" do
-      @command.name.should eq "shell"
+      expect(@command.name).to eq "shell"
     end
   end
 
   describe "#execute" do
     it "should read a line of input from stdin" do
-      Readline.should_receive(:readline)
-      @command.stub(:welcome_user)
-      @command.stub(:terminate_gracefully)
-      @command.execute(@input, @output).should eq true
+      expect(Readline).to receive(:readline)
+      allow(@command).to receive(:welcome_user)
+      allow(@command).to receive(:terminate_gracefully)
+      expect(@command.execute(@input, @output)).to eq true
     end
   end
 
@@ -25,73 +25,73 @@ describe Ppl::Command::Shell do
 
     before(:each) do
       @input.stdin = double(IO)
-      @input.stdin.stub(:tty?) { true }
+      allow(@input.stdin).to receive(:tty?) { true }
     end
 
     it "should not show a prompt if stdin isn't a tty" do
-      @input.stdin.stub(:tty?) { false }
-      Readline.should_receive(:readline).with("", true)
-      @command.stub(:welcome_user)
+      allow(@input.stdin).to receive(:tty?) { false }
+      expect(Readline).to receive(:readline).with("", true)
+      allow(@command).to receive(:welcome_user)
       @command.execute(@input, @output)
     end
 
     it "should show a prompt if stdin is a tty" do
-      @input.stdin.stub(:tty?) { true }
-      Readline.should_receive(:readline).with("ppl> ", true)
-      @command.stub(:welcome_user)
-      @command.stub(:terminate_gracefully)
+      allow(@input.stdin).to receive(:tty?) { true }
+      expect(Readline).to receive(:readline).with("ppl> ", true)
+      allow(@command).to receive(:welcome_user)
+      allow(@command).to receive(:terminate_gracefully)
       @command.execute(@input, @output)
     end
 
     it "should make a system call with the input from stdin" do
-      Readline.should_receive(:readline).and_return("email fred")
-      Readline.should_receive(:readline).and_return(false)
-      Kernel.should_receive(:system) do |command|
-        command.should include "email fred"
+      expect(Readline).to receive(:readline).and_return("email fred")
+      expect(Readline).to receive(:readline).and_return(false)
+      expect(Kernel).to receive(:system) do |command|
+        expect(command).to include "email fred"
       end
-      @command.stub(:welcome_user)
-      @command.stub(:terminate_gracefully)
-      @command.execute(@input, @output).should eq true
+      allow(@command).to receive(:welcome_user)
+      allow(@command).to receive(:terminate_gracefully)
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should exit on ctrl+c" do
-      Readline.should_receive(:readline).and_raise(Interrupt)
-      @command.stub(:welcome_user)
-      @command.stub(:terminate_gracefully)
-      @command.execute(@input, @output).should eq false
+      expect(Readline).to receive(:readline).and_raise(Interrupt)
+      allow(@command).to receive(:welcome_user)
+      allow(@command).to receive(:terminate_gracefully)
+      expect(@command.execute(@input, @output)).to eq false
     end
 
     it "should print a final newline on EOF so the user's prompt looks nice" do
-      @input.stdin.stub(:tty?) { true }
-      @output.should_receive(:line).with("")
-      Readline.should_receive(:readline).and_return(false)
-      @command.stub(:welcome_user)
+      allow(@input.stdin).to receive(:tty?) { true }
+      expect(@output).to receive(:line).with("")
+      expect(Readline).to receive(:readline).and_return(false)
+      allow(@command).to receive(:welcome_user)
       @command.execute(@input, @output)
     end
 
     it "should print a final newline on error so the user's prompt looks nice" do
-      @input.stdin.stub(:tty?) { true }
-      @output.should_receive(:line).with("")
-      @command.stub(:shell).and_raise(Interrupt)
+      allow(@input.stdin).to receive(:tty?) { true }
+      expect(@output).to receive(:line).with("")
+      allow(@command).to receive(:shell).and_raise(Interrupt)
       @command.execute(@input, @output)
     end
 
     it "should not print a final newline on EOF if stdin isn't a tty" do
-      @input.stdin.stub(:tty?) { false }
-      @output.should_not_receive(:line).with("")
-      Readline.should_receive(:readline).and_return(false)
-      @command.stub(:welcome_user)
+      allow(@input.stdin).to receive(:tty?) { false }
+      expect(@output).not_to receive(:line).with("")
+      expect(Readline).to receive(:readline).and_return(false)
+      allow(@command).to receive(:welcome_user)
       @command.execute(@input, @output)
     end
 
     it "should print a welcome message on the tty" do
-      @input.stdin.stub(:tty?) { true }
-      @output.should_receive(:line) do |line|
-        line.should include "ppl"
-        line.should include Ppl::Version
+      allow(@input.stdin).to receive(:tty?) { true }
+      expect(@output).to receive(:line) do |line|
+        expect(line).to include "ppl"
+        expect(line).to include Ppl::Version
       end
-      Readline.should_receive(:readline).and_return(false)
-      @command.stub(:terminate_gracefully)
+      expect(Readline).to receive(:readline).and_return(false)
+      allow(@command).to receive(:terminate_gracefully)
       @command.execute(@input, @output)
     end