ppl 4.0.1 → 4.0.2

data/spec/ppl/command/attribute_spec.rb

@@ -21,47 +21,47 @@ describe Ppl::Command::Attribute do
   describe "#execute" do
 
     it "should list all the contacts and the value of the attribute for each" do
-      @storage.should_receive(:load_address_book).and_return(@address_book)
-      @list_format.should_receive(:process).and_return("imagine this is a list")
-      @output.should_receive(:line).with("imagine this is a list")
-      @command.execute(@input, @output).should eq true
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@list_format).to receive(:process).and_return("imagine this is a list")
+      expect(@output).to receive(:line).with("imagine this is a list")
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should disable color output if :no_color is set" do
       @input.options[:no_color] = true
-      @storage.stub(:load_address_book).and_return(@address_book)
-      @list_format.should_receive(:disable_colors!)
-      @list_format.stub(:process)
-      @output.should_receive(:line)
-      @command.execute(@input, @output).should eq true
+      allow(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@list_format).to receive(:disable_colors!)
+      allow(@list_format).to receive(:process)
+      expect(@output).to receive(:line)
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should show the full list of attributes for the given contact" do
       @input.arguments.push("jdoe")
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @show_format.should_receive(:process).and_return("all the info")
-      @output.should_receive(:line).with("all the info")
-      @command.execute(@input, @output).should eq true
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@show_format).to receive(:process).and_return("all the info")
+      expect(@output).to receive(:line).with("all the info")
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should add the given value to the contact's attributes" do
       @input.arguments.push("jdoe", "anyvalue")
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @contact.should_receive(:phone_numbers).and_return([])
-      @storage.should_receive(:save_contact)
-      @command.execute(@input, @output).should eq true
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@contact).to receive(:phone_numbers).and_return([])
+      expect(@storage).to receive(:save_contact)
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should delete the given value from the contact's attributes" do
       phone_numbers = double(Array)
-      phone_numbers.should_receive(:delete)
+      expect(phone_numbers).to receive(:delete)
 
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @contact.should_receive(:phone_numbers).and_return(phone_numbers)
-      @storage.should_receive(:save_contact).and_return(true)
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@contact).to receive(:phone_numbers).and_return(phone_numbers)
+      expect(@storage).to receive(:save_contact).and_return(true)
       @input.arguments = ["jdoe", "somevalue"]
       @input.options   = { :delete => true }
-      @command.execute(@input, @output).should eq true
+      expect(@command.execute(@input, @output)).to eq true
     end
 
   end

data/spec/ppl/command/bday_spec.rb

@@ -15,31 +15,31 @@ describe Ppl::Command::Bday do
 
   describe "#name" do
     it "should be 'bday'" do
-      @command.name.should eq "bday"
+      expect(@command.name).to eq "bday"
     end
   end
 
   describe "#execute" do
 
     it "should show the contact's birthday if no date is given" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @show_format.should_receive(:process).and_return("1970-01-01")
-      @output.should_receive(:line).with("1970-01-01")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@show_format).to receive(:process).and_return("1970-01-01")
+      expect(@output).to receive(:line).with("1970-01-01")
       @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 no birthday 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 birthday if a date is given" do
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @storage.should_receive(:save_contact) do |contact|
-        contact.birthday.strftime.should eq "1980-01-01"
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@storage).to receive(:save_contact) do |contact|
+        expect(contact.birthday.strftime).to eq "1980-01-01"
       end
       @input.arguments = ["jim", "1980-01-01"]
       @command.execute(@input, @output)

data/spec/ppl/command/completion_spec.rb

@@ -10,16 +10,16 @@ describe Ppl::Command::Completion do
 
   describe "#name" do
     it "should be 'completion'" do
-      @command.name.should eq "completion"
+      expect(@command.name).to eq "completion"
     end
   end
 
   describe "#execute" do
 
     before(:each) do
-      @directory.stub(:path).and_return("")
-      File.stub(:exists?).and_return(true)
-      File.stub(:read)
+      allow(@directory).to receive(:path).and_return("")
+      allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:read)
     end
 
     it "should raise an error if no shell is specified" do
@@ -29,14 +29,14 @@ describe Ppl::Command::Completion do
 
     it "should raise an error if the shell is not recognised" do
       @input.arguments = ["invalidshell"]
-      File.should_receive(:exists?).with("/invalidshell").and_return(false)
+      expect(File).to receive(:exists?).with("/invalidshell").and_return(false)
       expect{@command.execute(@input, @output)}.to raise_error(Ppl::Error::CompletionNotFound)
     end
 
     it "should read the function from disk and print it to stdout" do
       @input.arguments = ["zsh"]
-      File.should_receive(:read).and_return("completion function")
-      @output.should_receive(:line).with("completion function")
+      expect(File).to receive(:read).and_return("completion function")
+      expect(@output).to receive(:line).with("completion function")
       @command.execute(@input, @output)
     end
 

data/spec/ppl/command/email_spec.rb

@@ -6,7 +6,7 @@ describe Ppl::Command::Email do
 
   describe "#name" do
     it "should be 'email'" do
-      @command.name.should eq "email"
+      expect(@command.name).to eq "email"
     end
   end
 
@@ -21,8 +21,8 @@ describe Ppl::Command::Email do
       @list_format = double(Ppl::Format::AddressBook)
       @show_format = double(Ppl::Format::Contact)
       @custom_format = double(Ppl::Format::Custom)
-      @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.storage = @storage
       @command.email_service = @service
       @command.list_format = @list_format
@@ -31,17 +31,17 @@ describe Ppl::Command::Email do
     end
 
     it "should list all email addresses by default" do
-      @storage.should_receive(:load_address_book).and_return(@address_book)
-      @list_format.should_receive(:process).and_return("imagine this is a list")
-      @output.should_receive(:line).with("imagine this is a list")
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@list_format).to receive(:process).and_return("imagine this is a list")
+      expect(@output).to receive(:line).with("imagine this is a list")
       @command.execute(@input, @output)
     end
 
     it "should show a single contact's addresses if one is specified" do
       @input.arguments << "jdoe"
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @show_format.should_receive(:process).and_return("imagine this is a list")
-      @output.should_receive(:line).with("imagine this is a list")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@show_format).to receive(:process).and_return("imagine this is a list")
+      expect(@output).to receive(:line).with("imagine this is a list")
       @command.execute(@input, @output)
     end
 
@@ -49,33 +49,33 @@ describe Ppl::Command::Email do
       @input.arguments << "jdoe"
       @input.options[:format] = "%e"
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("jdoe@example.org")
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @custom_format.should_receive(:format=).with("%e")
-      @custom_format.should_receive(:process).and_return("")
-      @output.should_receive(:line).with("")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@custom_format).to receive(:format=).with("%e")
+      expect(@custom_format).to receive(:process).and_return("")
+      expect(@output).to receive(:line).with("")
       @command.execute(@input, @output)
     end
     
     it "should delegate to the service layer to add a new email address" do
       @input.arguments = ["jdoe", "jdoe@example.org"]
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @service.should_receive(:add).with(@contact, "jdoe@example.org", @input.options)
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@service).to receive(:add).with(@contact, "jdoe@example.org", @input.options)
       @command.execute(@input, @output)
     end
 
     it "should delegate to the service layer to update an existing address" do
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("jdoe@example.org")
       @input.arguments = ["jdoe", "jdoe@example.org"]
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @service.should_receive(:update).with(@contact, "jdoe@example.org", {})
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@service).to receive(:update).with(@contact, "jdoe@example.org", {})
       @command.execute(@input, @output)
     end
 
     it "should delegate to the service layer to remove an email address" do
       @input.arguments = ["jdoe", "jdoe@example.org"]
       @input.options[:delete] = true
-      @storage.should_receive(:require_contact).and_return(@contact)
-      @service.should_receive(:remove).with(@contact, "jdoe@example.org")
+      expect(@storage).to receive(:require_contact).and_return(@contact)
+      expect(@service).to receive(:remove).with(@contact, "jdoe@example.org")
       @command.execute(@input, @output)
     end
 

data/spec/ppl/command/external_spec.rb

@@ -6,28 +6,28 @@ describe Ppl::Command::External do
     @output  = double(Ppl::Application::Output)
     @storage = double(Ppl::Adapter::Storage)
 
-    @storage.stub(:path).and_return("/contacts")
+    allow(@storage).to receive(:path).and_return("/contacts")
     @command.storage = @storage
   end
 
   describe "#execute" do
 
     it "should chdir to the location of the address book on disk" do
-      Dir.should_receive(:chdir).with("/contacts")
-      Kernel.stub(:exec)
+      expect(Dir).to receive(:chdir).with("/contacts")
+      allow(Kernel).to receive(:exec)
       @command.execute(@input, @output)
     end
 
     it "should run the specified command" do
-      Dir.stub(:chdir)
-      Kernel.should_receive(:exec).with("git remote")
+      allow(Dir).to receive(:chdir)
+      expect(Kernel).to receive(:exec).with("git remote")
       @command.execute(@input, @output)
     end
 
     it "should pass arguments through to the command" do
       @input.arguments = ["--help"]
-      Dir.stub(:chdir)
-      Kernel.should_receive(:exec).with("git remote --help")
+      allow(Dir).to receive(:chdir)
+      expect(Kernel).to receive(:exec).with("git remote --help")
       @command.execute(@input, @output)
     end
 

data/spec/ppl/command/help_spec.rb

@@ -11,13 +11,13 @@ describe Ppl::Command::Help do
     it "should accept a value" do
       suite = Object.new
       @command.command_suite = suite
-      @command.command_suite.should be suite
+      expect(@command.command_suite).to be suite
     end
   end
 
   describe "#name" do
     it "should be 'help'" do
-      @command.name.should eq "help"
+      expect(@command.name).to eq "help"
     end
   end
 
@@ -26,23 +26,23 @@ describe Ppl::Command::Help do
     it "should not list itself" do
       @command.command_suite.add_command(@command)
 
-      @output.should_receive(:line).with("usage: ppl <command>")
-      @output.should_receive(:line).with(nil)
-      @output.should_receive(:line).with(nil)
+      expect(@output).to receive(:line).with("usage: ppl <command>")
+      expect(@output).to receive(:line).with(nil)
+      expect(@output).to receive(:line).with(nil)
 
       @command.execute(nil, @output)
     end
 
     it "should list available commands" do
       command = double(Ppl::Application::Command)
-      command.should_receive(:name).twice.and_return("one")
-      command.should_receive(:description).and_return("The first command")
+      expect(command).to receive(:name).twice.and_return("one")
+      expect(command).to receive(:description).and_return("The first command")
       @command.command_suite.add_command(command)
 
-      @output.should_receive(:line).with("usage: ppl <command>")
-      @output.should_receive(:line).with(nil)
-      @output.should_receive(:line).with("   one   The first command")
-      @output.should_receive(:line).with(nil)
+      expect(@output).to receive(:line).with("usage: ppl <command>")
+      expect(@output).to receive(:line).with(nil)
+      expect(@output).to receive(:line).with("   one   The first command")
+      expect(@output).to receive(:line).with(nil)
 
       @command.execute(nil, @output)
     end
@@ -59,15 +59,15 @@ describe Ppl::Command::Help do
       @command.command_suite.add_command(command_foo)
       @command.command_suite.add_command(command_bar)
 
-      @output.should_receive(:line).with("usage: ppl <command>")
-      @output.should_receive(:line).with(nil)
+      expect(@output).to receive(:line).with("usage: ppl <command>")
+      expect(@output).to receive(:line).with(nil)
       [
         "   shortname          This is a command with a short name",
         "   veryverylongname   This is a command with a longer name",
       ].each do |line|
-        @output.should_receive(:line).with(line)
+        expect(@output).to receive(:line).with(line)
       end
-      @output.should_receive(:line).with(nil)
+      expect(@output).to receive(:line).with(nil)
 
       @command.execute(nil, @output)
     end

data/spec/ppl/command/init_spec.rb

@@ -8,15 +8,15 @@ describe Ppl::Command::Init do
 
   describe "#name" do
     it "should be 'init'" do
-      @command.name.should eq "init"
+      expect(@command.name).to eq "init"
     end
   end
 
   describe "#execute" do
 
     it "should pass the given path through to the storage adapter" do
-      Ppl::Adapter::Storage::Git.stub(:create_address_book) do |path|
-        path.should eq "/contacts"
+      allow(Ppl::Adapter::Storage::Git).to receive(:create_address_book) do |path|
+        expect(path).to eq "/contacts"
       end
       @input.arguments.push "/contacts"
       @command.execute(@input, @output)
@@ -26,8 +26,8 @@ describe Ppl::Command::Init do
       FakeFS.activate!
       Dir.mkdir "/current"
       Dir.chdir "/current"
-      Ppl::Adapter::Storage::Git.stub(:create_address_book) do |path|
-        path.should eq "/current"
+      allow(Ppl::Adapter::Storage::Git).to receive(:create_address_book) do |path|
+        expect(path).to eq "/current"
       end
       @command.execute(@input, @output)
       FakeFS.deactivate!

data/spec/ppl/command/ls_spec.rb

@@ -16,14 +16,14 @@ describe Ppl::Command::Ls do
 
   describe "#name" do
     it "should be 'ls'" do
-      @command.name.should eq "ls"
+      expect(@command.name).to eq "ls"
     end
   end
 
   describe "#execute" do
 
     before(:each) do
-      @storage.should_receive(:load_address_book).and_return(@address_book)
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
     end
 
     after(:each) do
@@ -31,24 +31,24 @@ describe Ppl::Command::Ls do
     end
 
     it "should show the list of contacts in the address book" do
-      @format.should_receive(:process).and_return("list of contacts")
-      @output.should_receive(:line).with("list of contacts")
+      expect(@format).to receive(:process).and_return("list of contacts")
+      expect(@output).to receive(:line).with("list of contacts")
     end
 
     it "should let the user specify a preset pretty format" do
       @input.options[:pretty] = "test"
-      @address_book.should_receive(:contacts).and_return([1])
-      @custom.should_receive(:use_preset).with("test")
-      @custom.should_receive(:process).and_return("list of contacts")
-      @output.should_receive(:line).with("list of contacts")
+      expect(@address_book).to receive(:contacts).and_return([1])
+      expect(@custom).to receive(:use_preset).with("test")
+      expect(@custom).to receive(:process).and_return("list of contacts")
+      expect(@output).to receive(:line).with("list of contacts")
     end
 
     it "should let the user specify a custom format" do
       @input.options[:format] = "%n"
-      @address_book.should_receive(:contacts).and_return([1])
-      @custom.should_receive(:format=).with("%n")
-      @custom.should_receive(:process).and_return("list of contacts")
-      @output.should_receive(:line).with("list of contacts")
+      expect(@address_book).to receive(:contacts).and_return([1])
+      expect(@custom).to receive(:format=).with("%n")
+      expect(@custom).to receive(:process).and_return("list of contacts")
+      expect(@output).to receive(:line).with("list of contacts")
     end
 
   end

data/spec/ppl/command/mutt_spec.rb

@@ -17,7 +17,7 @@ describe Ppl::Command::Mutt do
 
   describe "#name" do
     it "should be 'mutt'" do
-      @command.name.should eq "mutt"
+      expect(@command.name).to eq "mutt"
     end
   end
 
@@ -29,9 +29,9 @@ describe Ppl::Command::Mutt do
 
     it "should search the address book for the query" do
       @input.arguments.push "query"
-      @command.should_receive(:mutt_search).and_return(Ppl::Entity::AddressBook.new)
-      @output.should_receive(:line).with("No matches")
-      @command.execute(@input, @output).should eq false
+      expect(@command).to receive(:mutt_search).and_return(Ppl::Entity::AddressBook.new)
+      expect(@output).to receive(:line).with("No matches")
+      expect(@command.execute(@input, @output)).to eq false
     end
 
     it "should return email address matches" do
@@ -42,13 +42,13 @@ describe Ppl::Command::Mutt do
 
       @input.arguments.push "example"
 
-      @storage.should_receive(:load_address_book).and_return(@address_book)
-      @format.should_receive(:process).and_return("test@example.org\tTest User")
-      @output.should_receive(:line) do |line|
-        line.should include "Searching address book... 1 email addresses... 1 matching:"
-        line.should include "test@example.org\tTest User"
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@format).to receive(:process).and_return("test@example.org\tTest User")
+      expect(@output).to receive(:line) do |line|
+        expect(line).to include "Searching address book... 1 email addresses... 1 matching:"
+        expect(line).to include "test@example.org\tTest User"
       end
-      @command.execute(@input, @output).should eq true
+      expect(@command.execute(@input, @output)).to eq true
     end
 
     it "should only return matching email addresses" do
@@ -58,12 +58,12 @@ describe Ppl::Command::Mutt do
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("test@test.org")
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("prova@prova.org")
       @address_book.contacts.push(@contact)
-      @storage.stub(:load_address_book).and_return(@address_book)
-      @format.should_receive(:process) do |address_book|
-        address_book.contacts[0].email_addresses.length.should eq 1
-        address_book.contacts[0].email_addresses[0].address.should eq "prova@prova.org"
+      allow(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@format).to receive(:process) do |address_book|
+        expect(address_book.contacts[0].email_addresses.length).to eq 1
+        expect(address_book.contacts[0].email_addresses[0].address).to eq "prova@prova.org"
       end
-      @output.stub(:line)
+      allow(@output).to receive(:line)
       @command.execute(@input, @output)
     end
 
@@ -75,13 +75,13 @@ describe Ppl::Command::Mutt do
 
       @input.arguments.push "User"
 
-      @storage.should_receive(:load_address_book).and_return(@address_book)
-      @format.should_receive(:process).and_return("test@example.org\tTest User")
-      @output.should_receive(:line) do |line|
-        line.should include "Searching address book... 1 email addresses... 1 matching:"
-        line.should include "test@example.org\tTest User"
+      expect(@storage).to receive(:load_address_book).and_return(@address_book)
+      expect(@format).to receive(:process).and_return("test@example.org\tTest User")
+      expect(@output).to receive(:line) do |line|
+        expect(line).to include "Searching address book... 1 email addresses... 1 matching:"
+        expect(line).to include "test@example.org\tTest User"
       end
-      @command.execute(@input, @output).should eq true
+      expect(@command.execute(@input, @output)).to eq true
     end
 
 
@@ -93,11 +93,11 @@ describe Ppl::Command::Mutt do
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("prova@prova.org")
       @address_book.contacts << @contact
 
-      @storage.stub(:load_address_book).and_return(@address_book)
-      @format.stub(:process)
-      @output.stub(:line)
-      @output.should_receive(:line) do |line|
-        line.should include "Searching address book... 2 email addresses... 2 matching:"
+      allow(@storage).to receive(:load_address_book).and_return(@address_book)
+      allow(@format).to receive(:process)
+      allow(@output).to receive(:line)
+      expect(@output).to receive(:line) do |line|
+        expect(line).to include "Searching address book... 2 email addresses... 2 matching:"
       end
       @command.execute(@input, @output)
     end
@@ -112,23 +112,23 @@ describe Ppl::Command::Mutt do
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("joe@somewhere.com")
       @contact.email_addresses << Ppl::Entity::EmailAddress.new("LOUD@SHOUTING.COM")
       @address_book.contacts << @contact
-      @storage.stub(:load_address_book).and_return(@address_book)
-      @output.stub(:line)
+      allow(@storage).to receive(:load_address_book).and_return(@address_book)
+      allow(@output).to receive(:line)
     end
 
     it "should ignore case when matching names" do
       @input.arguments.push "joe schmoe"
-      @format.should_receive(:process) do |address_book|
-        address_book.contacts[0].email_addresses.length.should eq 2
+      expect(@format).to receive(:process) do |address_book|
+        expect(address_book.contacts[0].email_addresses.length).to eq 2
       end
       @command.execute(@input, @output)
     end
 
     it "should ignore case when matching email addresses" do
       @input.arguments.push "loud"
-      @format.should_receive(:process) do |address_book|
-        address_book.contacts[0].email_addresses.length.should eq 1
-        address_book.contacts[0].email_addresses[0].address.should eq "LOUD@SHOUTING.COM"
+      expect(@format).to receive(:process) do |address_book|
+        expect(address_book.contacts[0].email_addresses.length).to eq 1
+        expect(address_book.contacts[0].email_addresses[0].address).to eq "LOUD@SHOUTING.COM"
       end
       @command.execute(@input, @output)
     end