keybox 1.1.0 → 1.1.1

data/CHANGES

@@ -1,4 +1,14 @@
 = keybox Changelog
+=== Version 1.1.1
+
+* update all tests to use latest RSpec syntax
+* Fixed Bug [#8231] storage::container.find() does not work for anything but AccountEntry classes
+* Fixed Bug [#8330] finding user home directory may be wrong
+* Fixed Bug [#9827] Password field on add screen can be deleted
+* Fixed Bug [#10639] search is case sensitive
+* Fixed Bug [#11684] apostrophe's in additional information cause errors
+* Updated to using HighLine 1.2.9 (fixes Bug #9827)
+
 === Version 1.1.0
 
 * keybox now uses HighLine for terminal input/output

data/lib/keybox.rb

@@ -4,7 +4,7 @@ module Keybox
     APP_DATA_DIR    = File.join(APP_ROOT_DIR,"data").freeze
     APP_VENDOR_DIR  = File.join(APP_ROOT_DIR,"vendor").freeze
     
-    VERSION     = [1,1,0].freeze
+    VERSION     = [1,1,1].freeze
     AUTHOR      = "Jeremy Hinegardner".freeze
     AUTHOR_EMAIL= "jeremy@hinegardner.org".freeze
     HOMEPAGE    = "http://keybox.rubyforge.org".freeze

data/lib/keybox/application/base.rb

@@ -27,6 +27,15 @@ module Keybox
             attr_reader :stdin
             attr_reader :highline
 
+            class << self
+                # thank you Jamis - from Capistrano
+                def home_directory # :nodoc:
+                    ENV["HOME"] ||
+                        (ENV["HOMEPATH"] && "#{ENV["HOMEDRIVE"]}#{ENV["HOMEPATH"]}") ||
+                        "/"
+                end
+            end
+
             def initialize(argv = [])
                 # make sure we have an empty array, we could be
                 # initially passed nil explicitly
@@ -124,6 +133,7 @@ module Keybox
                 error_version_help
                 @highline.say "Keybox Base Application.  Doing nothing but output this line."
             end
+
         end
     end
 end

data/lib/keybox/application/password_safe.rb

@@ -16,7 +16,7 @@ module Keybox
             attr_accessor :actions
             attr_reader   :db
 
-            DEFAULT_DIRECTORY    = File.join(ENV["HOME"],".keybox")
+            DEFAULT_DIRECTORY    = File.join(home_directory,".keybox")
             DEFAULT_DB           = File.join(DEFAULT_DIRECTORY,"database.yaml")
             DEFAULT_CONFIG       = File.join(DEFAULT_DIRECTORY,"config.yaml")
             DEFAULT_COLOR_SCHEME = :dark_bg
@@ -352,7 +352,7 @@ module Keybox
                             columns << t.ljust(lengths[f])
                         end
                         cdata = columns.join(" " * 4)
-                        @highline.say("<%= color('#{line_number}',:line_number) %> <%= color('#{cdata}','#{color}') %>")
+                        @highline.say("<%= color('#{line_number}',:line_number) %> <%= color(%Q{#{cdata}},'#{color}') %>")
                     end
                 else
                     hsay "No matching records were found.", :information
@@ -373,18 +373,18 @@ module Keybox
                             next if value.length == 0
 
                             name_out = name.rjust(max_name_length)
-                            @highline.say("<%= color('#{name_out}', :name) %> <%= color(':',:separator) %> ")
+                            @highline.say("<%= color(%Q{#{name_out}}, :name) %> <%= color(':',:separator) %> ")
 
                             if match.private_field?(name) then
                                 @highline.ask(
-                                   "<%= color('#{value}',:private) %> <%= color('(press any key).', :prompt) %> "
+                                   "<%= color(%Q{#{value}},:private) %> <%= color('(press any key).', :prompt) %> "
                                 ) do |q|
                                     q.overwrite = true
                                     q.echo      = false
                                     q.character = true
                                 end
                                 
-                                @highline.say("<%= color('#{name_out}', :name) %> <%= color(':',:separator) %> <%= color('#{'*' * 20}', :private) %>")
+                                @highline.say("<%= color(%Q{#{name_out}}, :name) %> <%= color(':',:separator) %> <%= color('#{'*' * 20}', :private) %>")
                             else
                                 hsay value, :value
                             end

data/lib/keybox/highline_util.rb

@@ -47,9 +47,10 @@ module Keybox
 
         #
         # Prompt for input, returning what was typed.  Options can be
-        # passed as If echo is false,
-        # then '*' is printed out for each character typed in.  If it is
-        # any other character then that is output instead.
+        # passed in. 
+        #
+        # If echo is false,  then '*' is printed out for each character 
+        # typed in.  If it is any other character then that is output instead.
         #
         # If validate is set to true, then it will prompt twice and make
         # sure that the two values match
@@ -65,15 +66,11 @@ module Keybox
             validate = options[:validate] || false
 
             until validated do
-                line = @highline.ask("<%= color('#{original_prompt.rjust(width)}',:prompt) %> : ") { |q| q.echo = echo }
-                # ensure we are at the beginning of the line
-                @stdout.print "\r"
+                line = @highline.ask("<%= color(%Q{#{original_prompt.rjust(width)}},:prompt) %> : ") { |q| q.echo = echo }
 
                 # if we are validating then prompt again to validate
                 if validate then
-                    v = @highline.ask("<%= color('#{validation_prompt.rjust(width)}', :prompt) %> : ") { |q| q.echo = echo }
-                    # ensure we are at the beginning of the line
-                    @stdout.print "\r"
+                    v = @highline.ask("<%= color(%Q{#{validation_prompt.rjust(width)}}, :prompt) %> : ") { |q| q.echo = echo }
                    
                     # line on some terminals
                     if v != line then

data/lib/keybox/storage/container.rb

@@ -13,14 +13,14 @@ module Keybox
         # The container of the Keybox records.  The Container itself is
         # a Keybox::Storage::Record with a few extra methods.
         #
-        # A instance of a Container is created with a assprhase and a
+        # A instance of a Container is created with a passphrase and a
         # path to a file.  The passphrase can be anything that has a
         # to_s method.
         #
         #   container = Keybox::Storage::Container.new("i love ruby", "/tmp/database.yml")
         #
         # This will load from the given file with the given passphrase
-        # if the file exists, or it will initalize the container to
+        # if the file exists, or it will initialize the container to
         # accept records.
         #
         # The records are held decrypted in memory, so keep that in mind
@@ -30,7 +30,7 @@ module Keybox
         #
         #   record = Keybox::Storage::Record.new
         #   record.field1 = "data"
-        #   record.field1 = "some more data"
+        #   record.field2 = "some more data"
         #   
         #   container << record
         #
@@ -215,10 +215,15 @@ module Keybox
             # regexp will only be matched against those fields
             #
             def find(search_string,restricted_to = nil)
-                regex = Regexp.new(search_string)
+                case search_string
+                when Regexp
+                    regex = Regexp.new(search_string.source,search_string.options | Regexp::IGNORECASE)
+                else
+                    regex = Regexp.new(search_string.to_s,Regexp::IGNORECASE)
+                end
                 matches = []
                 @records.each do |record|
-                    restricted_to = restricted_to || ( record.fields - %w(password) )
+                    restricted_to = restricted_to || ( record.data_member_names - %w(password) )
                     record.data_members.each_pair do |k,v|
                         if regex.match(v) and restricted_to.include?(k.to_s) then
                             matches << record

data/lib/keybox/storage/record.rb

@@ -49,6 +49,12 @@ module Keybox
                 @modified
             end
 
+            # an array of the data member names
+            def data_member_names
+                @data_members.keys.collect { |n| n.to_s }
+            end
+
+
             # this is here so that after this class has been serialized
             # to a file the container can mark it as clean.  The class
             # should take care of marking itself dirty.

data/spec/base_app_spec.rb

@@ -1,55 +1,53 @@
 require 'keybox'
 require 'keybox/application/base'
 
-context "Keybox Base Application" do
+describe "Keybox Base Application" do
 
-    specify "nil argv should do nothing" do
+    it "nil argv should do nothing" do
         kba = Keybox::Application::Base.new(nil)
-        kba.error_message.should_be nil
+        kba.error_message.should == nil
     end
 
-    specify "executing with no args should have output on stdout" do
+    it "executing with no args should have output on stdout" do
         kba = Keybox::Application::Base.new(nil)
         kba.set_io(StringIO.new,StringIO.new,StringIO.new)
         kba.run
-        kba.stdout.string.size.should_be > 0
+        kba.stdout.string.size.should > 0
     end
 
-
-    specify "invalid options set the error message, exit 1 and have output on stderr" do
+    it "invalid options set the error message, exit 1 and have output on stderr" do
         kba = Keybox::Application::Base.new(["--invalid-option"])
         kba.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kba.run
         rescue SystemExit => se
-            kba.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kba.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kba.stdout.string.size.should_eql 0
+            kba.error_message.should =~ /Try.*--help/m 
+            kba.stderr.string.should =~ /Try.*--help/m 
+            kba.stdout.string.size.should == 0
             se.status.should == 1
         end
     end
 
-    specify "help has output on stdout and exits 0" do
+    it "help has output on stdout and exits 0" do
         kba = Keybox::Application::Base.new(["--h"]) 
         kba.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kba.run
         rescue SystemExit => se
-            se.status.should_eql 0
-            kba.stdout.string.length.should_be > 0
+            se.status.should == 0
+            kba.stdout.string.length.should > 0
         end
     end
 
-    specify "version has output on stdout and exits 0" do
+    it "version has output on stdout and exits 0" do
         kba = Keybox::Application::Base.new(["--ver"]) 
         kba.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kba.run
         rescue SystemExit => se
-            se.status.should_eql 0
-            kba.stdout.string.length.should_be > 0
+            se.status.should == 0
+            kba.stdout.string.length.should > 0
         end
     end
- 
 end
 

data/spec/convert_csv_spec.rb

@@ -1,12 +1,13 @@
 require 'tempfile'
 require 'keybox'
 require 'keybox/convert/csv'
-context "CSV Convert class" do
-    setup do 
+describe "CSV Convert class" do
+    before(:each) do 
         @import_csv = Tempfile.new("keybox_import.csv")
         @import_csv.puts "title,hostname,username,password,additional_info"
         @import_csv.puts "example host,host.example.com,guest,mysecretpassword,use this account only for honeybots"
         @import_csv.puts "example site,http://www.example.com,guest,mywebpassword,web forum login"
+        @import_csv.puts "example site,http://www.example.com,guest,mywebpassword,web forum login's information"
         @import_csv.close
 
         @bad_import_csv = Tempfile.new("keybox_bad_header.csv")
@@ -19,28 +20,29 @@ context "CSV Convert class" do
 
     end
 
-    teardown do
+    after(:each) do
         @import_csv.unlink
         @bad_import_csv.unlink
         @export_csv.unlink
     end
 
-    specify "able to load records from a file" do
+    it "able to load records from a file" do
         entries = Keybox::Convert::CSV.from_file(@import_csv.path)
-        entries.size.should_eql 2
-        entries[0].hostname.should_eql "host.example.com"
-        entries[1].password.should_eql "mywebpassword"
+        entries.size.should == 3
+        entries[0].hostname.should == "host.example.com"
+        entries[1].password.should == "mywebpassword"
+        entries[2].additional_info.should == "web forum login's information"
     end
 
-    specify "throws error if the header is bad" do
-        lambda { Keybox::Convert::CSV.from_file(@bad_import_csv.path) }.should_raise Keybox::ValidationError
+    it "throws error if the header is bad" do
+        lambda { Keybox::Convert::CSV.from_file(@bad_import_csv.path) }.should raise_error(Keybox::ValidationError)
     end
 
-    specify "able to write to a csv file" do
+    it "able to write to a csv file" do
         entries = Keybox::Convert::CSV.from_file(@import_csv.path)
         Keybox::Convert::CSV.to_file(entries,@export_csv.path)
         @export_csv.open
         data = @export_csv.read
-        data.size.should_be > 0
+        data.size.should > 0
     end
 end

data/spec/entry_spec.rb

@@ -1,62 +1,62 @@
 require 'keybox'
-context "Account Entry" do
-    specify "fields get set correctly" do
+describe "Account Entry" do
+    it "fields get set correctly" do
         k = Keybox::AccountEntry.new("a test title", "user")
-        k.username.should_eql "user"
-        k.title.should_eql "a test title"
+        k.username.should == "user"
+        k.title.should == "a test title"
     end
 
-    specify "fields can be accessed" do
+    it "fields can be accessed" do
         k = Keybox::AccountEntry.new("a test title", "user")
-        k.fields.should_include "title"
-        k.fields.should_include "username"
-        k.fields.should_include "additional_info"
+        k.fields.should be_include("title")
+        k.fields.should be_include("username")
+        k.fields.should be_include("additional_info")
     end
 
-    specify "fields can be private or visible" do
+    it "fields can be private or visible" do
         k = Keybox::AccountEntry.new("a test title", "user")
-        k.private_fields.size.should_eql 0
-        k.visible_field?("title").should_eql true
+        k.private_fields.size.should == 0
+        k.visible_field?("title").should == true
     end
 end
 
-context "Host Account" do
-    specify "fields get set correctly" do
+describe "Host Account" do
+    it "fields get set correctly" do
         ha = Keybox::HostAccountEntry.new("a title", "host", "user", "password")
-        ha.title.should_eql "a title"
-        ha.username.should_eql "user"
-        ha.hostname.should_eql "host"
-        ha.password.should_eql "password"
+        ha.title.should == "a title"
+        ha.username.should == "user"
+        ha.hostname.should == "host"
+        ha.password.should == "password"
     end
 
-    specify "password is displayable, private and non-visible" do
+    it "password is displayable, private and non-visible" do
         ha = Keybox::HostAccountEntry.new("a title", "host", "user", "password")
-        ha.display_fields.should_include "password"
-        ha.private_fields.should_include "password"
-        ha.visible_fields.should_not_include "password"
+        ha.display_fields.should be_include("password")
+        ha.private_fields.should be_include("password")
+        ha.visible_fields.should_not be_include("password")
     end
 end
 
-context "URL Account" do
-    specify "fields get set correctly" do
+describe "URL Account" do
+    it "fields get set correctly" do
         urla = Keybox::URLAccountEntry.new("url title", "http://www.example.com", "someuser")
-        urla.title.should_eql "url title"
-        urla.url.should_eql "http://www.example.com"
-        urla.username.should_eql "someuser"
+        urla.title.should == "url title"
+        urla.url.should == "http://www.example.com"
+        urla.username.should == "someuser"
     end
 
-    specify "password hash is used" do
+    it "password hash is used" do
         container = Keybox::Storage::Container.new("i love ruby", "/tmp/junk.yml")
         urla = Keybox::URLAccountEntry.new("url title", "http://www.example.com", "someuser")
         container << urla
-        urla.password.should_eql "589c0d91d"
+        urla.password.should == "589c0d91d"
     end
 
-    specify "there is no password storage field, but there a private password field" do
+    it "there is no password storage field, but there a private password field" do
         urla = Keybox::URLAccountEntry.new("url title", "http://www.example.com", "someuser")
-        urla.fields.should_not_include "password"
-        urla.private_fields.should_include "password"
-        urla.private_field?("password").should_eql true
+        urla.fields.should_not be_include("password")
+        urla.private_fields.should be_include("password")
+        urla.private_field?("password").should == true
     end
 
 end

data/spec/keybox_app_spec.rb

@@ -2,8 +2,8 @@ require 'tempfile'
 require 'keybox'
 require 'keybox/application/password_safe'
 
-context "Keybox Password Safe Application" do
-    setup do 
+describe "Keybox Password Safe Application" do
+    before(:each) do 
 
         @passphrase = "i love ruby"
         @testing_db = Tempfile.new("kps_db.yml")
@@ -12,13 +12,16 @@ context "Keybox Password Safe Application" do
         container = Keybox::Storage::Container.new(@passphrase, @testing_db.path)
         container << Keybox::HostAccountEntry.new("test account","localhost","guest", "rubyrocks")
         container << Keybox::URLAccountEntry.new("example site", "http://www.example.com", "rubyhacker")
+        apos = Keybox::HostAccountEntry.new("a title","hostname","login", "password")
+        apos.additional_info = "Someone's additional information"
+        container << apos
         container.save
-        container.save("/tmp/jjh-db.yml")
 
         @import_csv = Tempfile.new("keybox_import.csv")
         @import_csv.puts "title,hostname,username,password,additional_info"
         @import_csv.puts "example host,host.example.com,guest,mysecretpassword,use this account only for honeybots"
         @import_csv.puts "example site,http://www.example.com,guest,mywebpassword,web forum login"
+        @import_csv.puts "example site,http://www.example.com,guest,mywebpassword,web forum's login"
         @import_csv.close
 
         @bad_import_csv = Tempfile.new("keybox_bad_header.csv")
@@ -31,7 +34,7 @@ context "Keybox Password Safe Application" do
 
     end
 
-    teardown do
+    after(:each) do
         @testing_db.unlink
         @testing_cfg.unlink
         @import_csv.unlink
@@ -40,50 +43,50 @@ context "Keybox Password Safe Application" do
 
     end
 
-    specify "nil argv should do nothing" do
+    it "nil argv should do nothing" do
         kps = Keybox::Application::PasswordSafe.new
-        kps.error_message.should_be nil
+        kps.error_message.should == nil
     end
 
-    specify "executing with no args should have output on stdout" do
+    it "executing with no args should have output on stdout" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path])
         kps.set_io(StringIO.new(@passphrase),StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.size.should_be > 0
+        kps.stdout.string.size.should > 0
     end
 
-    specify "general options get set correctly" do
+    it "general options get set correctly" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--debug", "--no-use-hash-for-url"])
         kps.merge_options
-        kps.options.db_file.should_eql @testing_db.path
-        kps.options.config_file.should_eql @testing_cfg.path
-        kps.options.debug.should_eql true
-        kps.options.use_password_hash_for_url.should_eql false
+        kps.options.db_file.should == @testing_db.path
+        kps.options.config_file.should == @testing_cfg.path
+        kps.options.debug.should == true
+        kps.options.use_password_hash_for_url.should == false
     end
 
-    specify "more than one command options is an error" do
+    it "more than one command options is an error" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--add", "account", "--edit", "account"])
         kps.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kps.run
         rescue SystemExit => se
-            kps.error_message.should_satisfy { |msg| msg =~ /Only one of/m }
-            kps.stderr.string.should_satisfy { |msg| msg =~ /Only one of/m }
-            se.status.should_eql 1
+            kps.error_message.should =~ /Only one of/m 
+            kps.stderr.string.should =~ /Only one of/m
+            se.status.should == 1
         end
     end
 
-    specify "space separated words are okay for names" do
+    it "space separated words are okay for names" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--add", "An Example"])
         prompted_values = [@passphrase, "An example"] + %w(example.com someuser apassword apassword noinfo yes)
         stdin = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 3
+        kps.db.records.size.should == 4
     end
 
 
-    specify "invalid options set the error message, exit 1 and have output on stderr" do
+    it "invalid options set the error message, exit 1 and have output on stderr" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, 
                                                      "-c", @testing_cfg.path,
                                                      "--invalid-option"])
@@ -91,83 +94,83 @@ context "Keybox Password Safe Application" do
         begin
             kps.run
         rescue SystemExit => se
-            kps.error_message.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kps.stderr.string.should_satisfy { |msg| msg =~ /Try.*--help/m }
-            kps.stdout.string.size.should_eql 0
+            kps.error_message.should =~ /Try.*--help/m 
+            kps.stderr.string.should =~ /Try.*--help/m 
+            kps.stdout.string.size.should == 0
             se.status.should == 1
         end
     end
 
-    specify "help has output on stdout and exits 0" do
+    it "help has output on stdout and exits 0" do
         kps = Keybox::Application::PasswordSafe.new(["--h"]) 
         kps.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kps.run
         rescue SystemExit => se
-            se.status.should_eql 0
-            kps.stdout.string.length.should_be > 0
+            se.status.should == 0
+            kps.stdout.string.length.should > 0
         end
     end
 
-    specify "version has output on stdout and exits 0" do
+    it "version has output on stdout and exits 0" do
         kps = Keybox::Application::PasswordSafe.new(["--ver"]) 
         kps.set_io(StringIO.new,StringIO.new,StringIO.new)
         begin
             kps.run
         rescue SystemExit => se
-            se.status.should_eql 0
-            kps.stdout.string.length.should_be > 0
+            se.status.should == 0
+            kps.stdout.string.length.should > 0
         end
     end
     
-    specify "prompted for password twice to create database initially" do
+    it "prompted for password twice to create database initially" do
         File.unlink(@testing_db.path)
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path])
         stdin  = StringIO.new([@passphrase,@passphrase].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 0
-        kps.stdout.string.should_satisfy { |msg| msg =~ /Creating initial database./m }
-        kps.stdout.string.should_satisfy { |msg| msg =~ /Initial Password for/m }
+        kps.db.records.size.should == 0
+        kps.stdout.string.should =~ /Creating initial database./m 
+        kps.stdout.string.should =~ /Initial Password for/m 
     end
 
-    specify "file can be opened with password" do
+    it "file can be opened with password" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path])
         stdin  = StringIO.new(@passphrase + "\n")
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 2
+        kps.db.records.size.should == 3
     end
 
-    specify "adding an entry to the database works" do
+    it "adding an entry to the database works" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--add", "example.com"])
         prompted_values = [@passphrase] + %w(example.com example.com someuser apassword apassword noinfo yes)
         stdin  = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 3
+        kps.db.records.size.should == 4
     end
 
-    specify "editing an entry in the database works" do
+    it "editing an entry in the database works" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--edit", "localhost"])
         prompted_values = [@passphrase] + %w(yes example.com example.com someother anewpassword anewpassword someinfo yes)
         stdin  = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 2
-        kps.db.find("someother")[0].additional_info.should_eql "someinfo"
+        kps.db.records.size.should == 3
+        kps.db.find("someother")[0].additional_info.should == "someinfo"
     end
 
-    specify "add a url entry to the database" do
+    it "add a url entry to the database" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--use-hash-for-url", "--add", "http://www.example.com"])
         prompted_values = [@passphrase] + %w(www.example.com http://www.example.com someuser noinfo yes)
         stdin  = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 3
+        kps.db.records.size.should == 4
     end
 
-    specify "double prompting on failed password for entry to the database works" do
+    it "double prompting on failed password for entry to the database works" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, 
                                                      "-c", @testing_cfg.path, 
                                                      "--add", "example.com"])
@@ -175,125 +178,125 @@ context "Keybox Password Safe Application" do
         stdin  = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 3
+        kps.db.records.size.should == 4
     end
 
-    specify "able to delete an entry" do
+    it "able to delete an entry" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--delete", "example"])
         prompted_values = [@passphrase] + %w(Yes)
         stdin = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 1
-        kps.stdout.string.should_satisfy { |msg| msg =~ /example' deleted/ }
+        kps.db.records.size.should == 2
+        kps.stdout.string.should =~ /example' deleted/ 
     end
 
-    specify "able to cancel deletion" do
+    it "able to cancel deletion" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--delete", "example"])
         prompted_values = [@passphrase] + %w(No)
         stdin = StringIO.new(prompted_values.join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.db.records.size.should_eql 2
-        kps.stdout.string.should_satisfy { |msg| msg =~ /example' deleted/ }
+        kps.db.records.size.should == 3
+        kps.stdout.string.should =~ /example' deleted/ 
     end
 
-    specify "list all the entries" do
+    it "list all the entries" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--list"])
         stdin = StringIO.new(@passphrase)
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /2./m }
+        kps.stdout.string.should =~ /2./m 
     end
 
-    specify "listing no entries found" do
+    it "listing no entries found" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--list", "nothing"])
         stdin = StringIO.new(@passphrase)
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /No matching records were found./ }
+        kps.stdout.string.should =~ /No matching records were found./ 
     end
 
-    specify "showing no entries found" do
+    it "showing no entries found" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--show", "nothing"])
         stdin = StringIO.new(@passphrase)
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /No matching records were found./ }
+        kps.stdout.string.should =~ /No matching records were found./ 
     end
 
 
-    specify "show all the entries" do
+    it "show all the entries" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--show"])
-        stdin = StringIO.new([@passphrase, "", ""].join("\n"))
+        stdin = StringIO.new([@passphrase, "", "", ""].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /2./m }
+        kps.stdout.string.should =~ /2./m 
     end
 
-    specify "changing master password works" do
+    it "changing master password works" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--master-password"])
         stdin  = StringIO.new([@passphrase, "I really love ruby.", "I really love ruby."].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /New master password set/m }
+        kps.stdout.string.should =~ /New master password set/m 
     end
 
-    specify "master password must be non-zero" do
+    it "master password must be non-zero" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path, "--master-password"])
         stdin  = StringIO.new([@passphrase, "", ""].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         begin
             kps.run
         rescue SystemExit => se
-            kps.stdout.string.should_satisfy { |msg| msg =~ /Passphrase is not strong enough./m }
-            se.status.should_eql 1
+            kps.stdout.string.should =~ /Passphrase is not strong enough./m 
+            se.status.should == 1
         end
     end
 
-    specify "importing from a valid csv file" do
+    it "importing from a valid csv file" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path,"-i", @import_csv.path])
         stdin  = StringIO.new([@passphrase, @passphrase].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /Imported \d* records from/m }
+        kps.stdout.string.should =~ /Imported \d* records from/m 
     end
 
-    specify "Error message give on invalid imported csv" do
+    it "Error message give on invalid imported csv" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path,"-i", @bad_import_csv.path])
         stdin  = StringIO.new([@passphrase, @passphrase].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         begin
             kps.run
         rescue SystemExit => se
-            kps.stdout.string.should_satisfy { |msg| msg =~ /Error: There must be a header on the CSV /m }
-            se.status.should_eql 1
+            kps.stdout.string.should =~ /Error: There must be a header on the CSV /m 
+            se.status.should == 1
         end
     end
 
-    specify "able to export to a csv" do
+    it "able to export to a csv" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path,"-x", @export_csv.path])
         stdin  = StringIO.new([@passphrase, @passphrase].join("\n"))
         kps.set_io(stdin,StringIO.new,StringIO.new)
         kps.run
-        kps.stdout.string.should_satisfy { |msg| msg =~ /Exported \d* records to/m }
+        kps.stdout.string.should  =~ /Exported \d* records to/m 
     end
 
-    specify "able to turn off color schemes" do
+    it "able to turn off color schemes" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path,"--color","none"])
         kps.set_io(StringIO.new(@passphrase),StringIO.new,StringIO.new)
         kps.run
-        kps.options.color_scheme.should_equal :none
+        kps.options.color_scheme.should == :none
     end
 
-    specify "an invalid color scheme results in a no color scheme" do
+    it "an invalid color scheme results in a no color scheme" do
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path,"--color","dne"])
         kps.set_io(StringIO.new(@passphrase),StringIO.new,StringIO.new)
         kps.run
-        kps.options.color_scheme.should_equal :none
+        kps.options.color_scheme.should == :none
     end
 
-    specify "an incomplete color scheme results in an error message and then 'none' color scheme" do
+    it "an incomplete color scheme results in an error message and then 'none' color scheme" do
         bad_color_scheme = { :bad => [:bold, :white, :on_magenta] }
         File.open("/tmp/test.color_scheme.yaml", "w+") { |f| f.write(bad_color_scheme.to_yaml) }
         kps = Keybox::Application::PasswordSafe.new(["-f", @testing_db.path, "-c", @testing_cfg.path,"--color","test"])
@@ -301,7 +304,11 @@ context "Keybox Password Safe Application" do
         kps.run
 
         File.unlink("/tmp/test.color_scheme.yaml")
-        kps.stdout.string.should_satisfy { |msg| msg =~ /It is missing the following items/m }
-        kps.options.color_scheme.should_equal :none
+        kps.stdout.string.should =~ /It is missing the following items/m 
+        kps.options.color_scheme.should == :none
+    end
+
+    it "should have a valid home directory" do
+        File.dirname(Keybox::Application::PasswordSafe::DEFAULT_DIRECTORY).size.should > 0
     end
 end