ppl 4.0.1 → 4.0.2

data/spec/ppl/application/command_spec.rb

@@ -14,7 +14,7 @@ describe Ppl::Application::Command do
     it "should accept a storage adapter" do
       storage = double(Ppl::Adapter::Storage)
       @command.storage = storage
-      @command.storage.should be storage
+      expect(@command.storage).to be storage
     end
   end
 
@@ -30,7 +30,7 @@ describe Ppl::Application::Command do
         add_property :some_property
         some_property "a value"
       end
-      TestCommand456.some_property.should eq "a value"
+      expect(TestCommand456.some_property).to eq "a value"
     end
 
     it "should expose properties as instance variables too" do
@@ -39,7 +39,7 @@ describe Ppl::Application::Command do
         some_property "a value"
       end
       instance = TestCommand789.new
-      instance.some_property.should eq "a value"
+      expect(instance.some_property).to eq "a value"
     end
 
     it "should allow properties to be overwritten by instance variables" do
@@ -49,21 +49,21 @@ describe Ppl::Application::Command do
       end
       instance = TestCommand901.new
       instance.some_property = "different"
-      instance.some_property.should eq "different"
+      expect(instance.some_property).to eq "different"
     end
   end
 
   describe "#name=" do
     it "should allow the name to be set as an instance variable" do
       @command.name = "testing"
-      @command.name.should eq "testing"
+      expect(@command.name).to eq "testing"
     end
   end
 
   describe "#description=" do
     it "should allow the description to be set as an instance variable" do
       @command.description = "testing"
-      @command.description.should eq "testing"
+      expect(@command.description).to eq "testing"
     end
   end
 
@@ -73,7 +73,7 @@ describe Ppl::Application::Command do
         name "new_for_test"
       end
       command = TestCommand123.new
-      command.name.should eq "new_for_test"
+      expect(command.name).to eq "new_for_test"
     end
   end
 
@@ -83,7 +83,7 @@ describe Ppl::Application::Command do
         description "desc_for_test"
       end
       command = TestCommand123.new
-      command.description.should eq "desc_for_test"
+      expect(command.description).to eq "desc_for_test"
     end
   end
 

data/spec/ppl/application/command_suite_spec.rb

@@ -16,23 +16,23 @@ describe Ppl::Application::CommandSuite do
   describe "#add_command" do
     it "should accept a command" do
       @command_suite.add_command(Ppl::Application::Command.new)
-      @command_suite.count.should be 3
+      expect(@command_suite.count).to be 3
     end
   end
 
   describe "#find_command" do
     it "should find a command matching the given name" do
-      @command_suite.find_command("foo").should be @foo_command
+      expect(@command_suite.find_command("foo")).to be @foo_command
     end
     it "should return nil if no commands match the given name" do
-      @command_suite.find_command("baz").should be nil
+      expect(@command_suite.find_command("baz")).to be nil
     end
   end
 
   describe "#each" do
     it "should yield commands" do
-      @command_suite
-        .should_receive(:each)
+      expect(@command_suite)
+        .to receive(:each)
         .and_yield(@foo_command)
         .and_yield(@bar_command)
       @command_suite.each do |c| end
@@ -42,8 +42,8 @@ describe Ppl::Application::CommandSuite do
   describe "#sort_by_name" do
     it "should sort the commands alphabetically by name" do
       @command_suite.sort_by_name
-      @command_suite[0].name.should eq "bar"
-      @command_suite[1].name.should eq "foo"
+      expect(@command_suite[0].name).to eq "bar"
+      expect(@command_suite[1].name).to eq "foo"
     end
   end
 

data/spec/ppl/application/configuration_spec.rb

@@ -11,44 +11,44 @@ describe Ppl::Application::Configuration do
 
   describe "#address_book_path" do
     it "should default to the current working directory" do
-      @config.address_book_path.should eq Dir.pwd
+      expect(@config.address_book_path).to eq Dir.pwd
     end
     it "should be configurable by the user's config file" do
-      @config.stub(:user_configuration) do
+      allow(@config).to receive(:user_configuration) do
         {"address book" => {"path" => "/contacts"}}
       end
-      @config.address_book_path.should eq "/contacts"
+      expect(@config.address_book_path).to eq "/contacts"
     end
   end
 
   describe "#aliases" do
     it "should return a hash" do
-      @config.aliases.should be_a(Hash)
+      expect(@config.aliases).to be_a(Hash)
     end
   end
 
   describe "#color_enabled" do
 
     it "should return true if color is explicitly enabled" do
-      @config.stub(:user_configuration).and_return({
+      allow(@config).to receive(:user_configuration).and_return({
         "color" => {
           "cmd" => "true",
         },
       })
-      @config.color_enabled("cmd").should eq true
+      expect(@config.color_enabled("cmd")).to eq true
     end
 
     it "should return false if color is not explicitly enabled" do
-      @config.color_enabled("cmd").should eq false
+      expect(@config.color_enabled("cmd")).to eq false
     end
 
     it "should return false if color is explicitly disabled" do
-      @config.stub(:user_configuration).and_return({
+      allow(@config).to receive(:user_configuration).and_return({
         "color" => {
           "cmd" => "false",
         },
       })
-      @config.color_enabled("cmd").should eq false
+      expect(@config.color_enabled("cmd")).to eq false
     end
 
   end
@@ -56,8 +56,8 @@ describe Ppl::Application::Configuration do
   describe "#command_colors" do
 
     before(:each) do
-      @config.stub(:color_enabled).and_return(true)
-      @config.stub(:user_configuration).and_return({
+      allow(@config).to receive(:color_enabled).and_return(true)
+      allow(@config).to receive(:user_configuration).and_return({
         "color \"ls\"" => {
           "id" => "blue",
         },
@@ -65,19 +65,19 @@ describe Ppl::Application::Configuration do
     end
 
     it "should return the colors configured for the given command" do
-      @config.command_colors("ls").should eq({
+      expect(@config.command_colors("ls")).to eq({
         "id" => "blue",
       })
     end
 
     it "should return an empty hash if colors aren't enabled for the command" do
-      @config.stub(:color_enabled).and_return(false)
-      @config.command_colors("ls").should eq({})
+      allow(@config).to receive(:color_enabled).and_return(false)
+      expect(@config.command_colors("ls")).to eq({})
     end
 
     it "should return nil if no colors are configured for the given command" do
-      @config.stub(:user_configuration).and_return({})
-      @config.command_colors("show").should eq(nil)
+      allow(@config).to receive(:user_configuration).and_return({})
+      expect(@config.command_colors("show")).to eq(nil)
     end
 
   end

data/spec/ppl/application/input_spec.rb

@@ -6,13 +6,13 @@ describe Ppl::Application::Input do
 
   describe "#arguments" do
     it "should be an array" do
-      @input.arguments.should be_an(Array)
+      expect(@input.arguments).to be_an(Array)
     end
   end
 
   describe "#options" do
     it "should be a hash" do
-      @input.options.should be_a(Hash)
+      expect(@input.options).to be_a(Hash)
     end
   end
 

data/spec/ppl/application/router_spec.rb

@@ -20,35 +20,35 @@ describe Ppl::Application::Router do
   describe "#default=" do
     it "should accept the name of the default command" do
       @router.default = "one"
-      @router.default.should eq "one"
+      expect(@router.default).to eq "one"
     end
   end
 
   describe "#route" do
 
     it "should return the command whose name matches the given argument" do
-      @router.route("two").should be @cmd_two
+      expect(@router.route("two")).to be @cmd_two
     end
 
     it "should return nil if no matching command can be found" do
-      @router.route("three").should be nil
+      expect(@router.route("three")).to be nil
     end
 
     it "should fall back to the default command if the given one isn't found" do
       @router.default = "one"
-      @router.route("three").should be @cmd_one
+      expect(@router.route("three")).to be @cmd_one
     end
 
     it "should apply the aliases if the argument doesn't match a command" do
       @router.aliases = {"t" => "two"}
-      @router.route("t").should be @cmd_two
+      expect(@router.route("t")).to be @cmd_two
     end
 
     it "should return a Ppl::Command::External if the input matches a bang alias" do
-      @external.should_receive(:name=).with("t")
-      @external.should_receive(:command=).with("two")
+      expect(@external).to receive(:name=).with("t")
+      expect(@external).to receive(:command=).with("two")
       @router.aliases = {"t" => "!two"}
-      @router.route("t").should be @external
+      expect(@router.route("t")).to be @external
     end
 
   end

data/spec/ppl/application/shell_spec.rb

@@ -15,94 +15,94 @@ describe Ppl::Application::Shell do
 
     it "should return false if the given command isn't found" do
       @input.arguments = ["foo"]
-      @router
-        .should_receive(:route)
+      expect(@router)
+        .to receive(:route)
         .with("foo")
         .and_return(nil)
-      @shell.run(@input, @output).should eq false
+      expect(@shell.run(@input, @output)).to eq false
     end
 
     it "should execute the given command" do
       @input.arguments = ["foo"]
-      @router
-        .should_receive(:route)
+      expect(@router)
+        .to receive(:route)
         .with("foo")
         .and_return(@command)
 
-      @command.should_receive(:options)
-      @command
-        .should_receive(:execute)
+      expect(@command).to receive(:options)
+      expect(@command)
+        .to receive(:execute)
         .and_return(true)
 
-      @shell.run(@input, @output).should eq true
+      expect(@shell.run(@input, @output)).to eq true
     end
 
     it "should not pass the command name in the input to the command itself" do
       @input.arguments = ["mv", "foo", "bar"]
-      @router
-        .should_receive(:route)
+      expect(@router)
+        .to receive(:route)
         .with("mv")
         .and_return(@command)
 
-      @command.should_receive(:options)
-      @command.should_receive(:execute) do |input, output|
-        input.arguments.should eq ["foo", "bar"]
+      expect(@command).to receive(:options)
+      expect(@command).to receive(:execute) do |input, output|
+        expect(input.arguments).to eq ["foo", "bar"]
       end
       @shell.run(@input, @output)
     end
 
     it "should return false if the command throws an exception" do
-      @command.should_receive(:options)
-      @command
-        .should_receive(:execute)
+      expect(@command).to receive(:options)
+      expect(@command)
+        .to receive(:execute)
         .and_raise(StandardError)
 
-      @router
-        .should_receive(:route)
+      expect(@router)
+        .to receive(:route)
         .and_return(@command)
 
-      @output.should_receive(:error)
+      expect(@output).to receive(:error)
 
       @shell.run(@input, @output)
     end
 
     it "should not do any option parsing for Ppl::Command::External instances" do
       external = Ppl::Command::External.new("ls", "ls", "List directory contents")
-      external.stub(:execute).and_return(true)
-      @shell.should_receive(:select_command).and_return(external)
-      external.should_not_receive(:options)
+      allow(external).to receive(:execute).and_return(true)
+      expect(@shell).to receive(:select_command).and_return(external)
+      expect(external).not_to receive(:options)
       @shell.run(@input, @output)
     end
 
     it "should send exception messages to stderr" do
-      @command.should_receive(:options)
-      @command.should_receive(:execute) { raise "Pool's Closed" }
-      @router.should_receive(:route).and_return(@command)
-      @output.should_receive(:error).with("ppl: Pool's Closed")
+      expect(@command).to receive(:options)
+      expect(@command).to receive(:execute) { raise "Pool's Closed" }
+      expect(@router).to receive(:route).and_return(@command)
+      expect(@output).to receive(:error).with("ppl: Pool's Closed")
       @shell.run(@input, @output)
     end
 
     it "should handle ContactNotFound errors nicely" do
-      @command.stub(:options)
-      @command.should_receive(:execute) { raise Ppl::Error::ContactNotFound, "example" }
-      @router.should_receive(:route).and_return(@command)
-      @output.should_receive(:error).with("ppl: Contact 'example' not found")
+      allow(@command).to receive(:options)
+      expect(@command).to receive(:execute) { raise Ppl::Error::ContactNotFound, "example" }
+      expect(@router).to receive(:route).and_return(@command)
+      expect(@output).to receive(:error).with("ppl: Contact 'example' not found")
       @shell.run(@input, @output)
     end
 
     it "should handle CompletionNotFound errors nicely" do
-      @command.stub(:options)
-      @command.should_receive(:execute) { raise Ppl::Error::CompletionNotFound, "example" }
-      @router.should_receive(:route).and_return(@command)
-      @output.should_receive(:error).with("ppl: No completion function available for 'example'")
+      allow(@command).to receive(:options)
+      expect(@command).to receive(:execute) { raise Ppl::Error::CompletionNotFound, "example" }
+      expect(@router).to receive(:route).and_return(@command)
+      expect(@output).to receive(:error).with("ppl: No completion function available for 'example'")
       @shell.run(@input, @output)
     end
 
     it "should handle PostalAddressNotFound errors nicely" do
-      @command.stub(:options)
-      @command.should_receive(:execute) { raise Ppl::Error::PostalAddressNotFound, "example" }
-      @router.should_receive(:route).and_return(@command)
-      @output.should_receive(:error).with("ppl: Postal address 'example' not found")
+      allow(@command).to receive(:options)
+      expect(@command).to receive(:execute) { raise Ppl::Error::PostalAddressNotFound, "example" }
+      expect(@router).to receive(:route).and_return(@command)
+      expect(@output).to receive(:error).with("ppl: Postal address 'example' not found")
       @shell.run(@input, @output)
     end
 

data/spec/ppl/command/add_spec.rb

@@ -12,7 +12,7 @@ describe Ppl::Command::Add do
 
   describe "#name" do
     it "should be 'add'" do
-      @command.name.should eq "add"
+      expect(@command.name).to eq "add"
     end
   end
 
@@ -28,12 +28,12 @@ describe Ppl::Command::Add do
     end
 
     it "should save a new contact" do
-      @storage.should_receive(:save_contact) do |contact|
-        contact.id.should eq "john"
-        contact.name.should be_a(Ppl::Entity::Name)
+      expect(@storage).to receive(:save_contact) do |contact|
+        expect(contact.id).to eq "john"
+        expect(contact.name).to be_a(Ppl::Entity::Name)
       end
-      @name_service
-        .should_receive(:parse)
+      expect(@name_service)
+        .to receive(:parse)
         .with("John Doe")
         .and_return(Ppl::Entity::Name.new)
       @input.arguments = ["john", "John Doe"]

data/spec/ppl/command/age_spec.rb

@@ -15,24 +15,24 @@ describe Ppl::Command::Age do
 
   describe "#name" do
     it "should be 'age'" do
-      @command.name.should eq "age"
+      expect(@command.name).to eq "age"
     end
   end
 
   describe "#execute" do
 
     it "should list contacts' ages if no arguments are given" do
-      @storage.should_receive(:load_address_book)
-      @list_format.should_receive(:process)
-      @output.should_receive(:line)
+      expect(@storage).to receive(:load_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 ages if one is specified" do
       @input.arguments = ["jdoe"]
-      @storage.should_receive(:require_contact)
-      @show_format.should_receive(:process)
-      @output.should_receive(:line)
+      expect(@storage).to receive(:require_contact)
+      expect(@show_format).to receive(:process)
+      expect(@output).to receive(:line)
       @command.execute(@input, @output)
     end