passwordsafe 0.0.3 → 0.0.4

data/.rvmrc

@@ -1 +1,2 @@
-rvm ruby-1.9.2-p0@pws
+rvm ruby-1.9.2@pws
+

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    passwordsafe (0.0.2)
+    passwordsafe (0.0.3)
       highline
       thor
 

data/README.md

@@ -6,16 +6,18 @@ Based on 'Tutorial: Build your own password safe with Ruby!' at http://rbjl.net/
 ## Currently implemented
 **NOTE** This gem is currently in alpha, if you'd like to try it and make suggestions feel free but please do not store valuble information in it yet.
 
-
     password add name password
 Use passwordsafe to add a password with NAME to the safe.  The utility will prompt for a master password to use to encrypt the file. *Do NOT loose your master password, it is unrecoverable!*
 
     password get name
 Use passwordsafe to retrive an existing password out of your safe.  The utility will prompt for a master password.
 
+    password list
+List all the existing password names in the safe.
+
+
 ## Not Implemented yet
 
-    password list
     password remove name
     password help
 

data/features/get.feature

@@ -9,7 +9,6 @@ Feature: Get
         And I type "masterpa$$"
         Then the output should contain "name: "
 
-    @announce
     Scenario: Get a password with a name that does not exist
         Given A safe exists with masterpassword "masterpa$$" and a "name" key
         When I run "password get name2" interactively

data/features/list.feature

@@ -0,0 +1,17 @@
+Feature: List
+    In order to see what passwords I have stored
+    As a user
+    I want to be able to list existing password names
+
+    Scenario: No passwords stored
+        Given A safe exists with masterpassword "masterpa$$" and "0" keys
+        When I run "password list" interactively
+        And I type "masterpa$$"
+        Then the output should contain "List: (none)"
+
+    Scenario: One password stored
+        Given A safe exists with masterpassword "masterpa$$" and a "pass" key
+        When I run "password list" interactively
+        And I type "masterpa$$"
+        Then the output should contain "List: pass"
+

data/features/step_definitions/safe_steps.rb

@@ -9,3 +9,13 @@ Given /^A safe exists with masterpassword "([^"]*)" and a "([^"]*)" key$/ do |ma
   end
 end
 
+Given /^A safe exists with masterpassword "([^"]*)" and "([^"]*)" keys$/ do |masterpass, keys|
+  in_current_dir do
+    safe = PasswordSafe::Safe.new(PasswordSafe::CLI::DEFAULTSAFE, masterpass)
+
+    keys.to_i.times do |i|
+      PasswordSafe::Keyring.new(safe).add "pass#{i}", "dummypass"
+    end
+  end
+end
+

data/lib/passwordsafe/cli.rb

@@ -29,6 +29,14 @@ module PasswordSafe
       end
     end
 
+    desc "list", "List the names of all the existing passwords in the safe"
+    def list
+      safe = make_safe
+      keys = PasswordSafe::Keyring.new(safe).list
+      puts "List: (none)" if keys.empty?
+      puts "List: #{keys.join(", ")}"
+    end
+
     no_tasks do
       def make_safe filename = DEFAULTSAFE
         masterpass = ask("Enter your master password:  ") { |q| q.echo = "x" }

data/lib/passwordsafe/version.rb

@@ -1,4 +1,4 @@
 module Passwordsafe
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end
 

data/spec/encryptor_spec.rb

@@ -2,54 +2,48 @@ require 'spec_helper'
 require 'passwordsafe/encryptor'
 
 describe PasswordSafe::Encryptor do
+  let(:encryptor) {(Class.new { include PasswordSafe::Encryptor}).new }
 
-  before(:each) do
-    klass = Class.new { include PasswordSafe::Encryptor}
-    @encryptor = klass.new
-  end
-  context "hash" do
+  describe "hash" do
     it "creates a password hash" do
-      @encryptor.should respond_to(:hash).with(1).argument
-      @encryptor.hash("test").should be_a(String)
+      encryptor.should respond_to(:hash).with(1).argument
+      encryptor.hash("test").should be_a(String)
     end
 
     it "creates the same hash given the same text" do
-      @encryptor.hash("test").should eq(@encryptor.hash("test"))
+      encryptor.hash("test").should eq(encryptor.hash("test"))
     end
 
     it "creates a different hash given different text" do
-      @encryptor.hash("test").should_not eq(@encryptor.hash("another"))
+      encryptor.hash("test").should_not eq(encryptor.hash("another"))
     end
   end
-  context "encrypt" do
-    before(:each) do
-      @string = "teststring"
-      @hash = @encryptor.hash("hashstring")
-    end
+  describe "encrypt" do
+    let(:string) { "teststring" }
+    let(:hash) { encryptor.hash("hashstring") }
 
     it "encrypts a string" do
-      @encryptor.should respond_to(:encrypt).with(2).arguments
-      @encryptor.encrypt(@string, @hash).should be_a(String)
+      encryptor.should respond_to(:encrypt).with(2).arguments
+      encryptor.encrypt(string, hash).should be_a(String)
     end
     it "creates the same string given the same text" do
-      @encryptor.encrypt(@string, @hash).should eq(@encryptor.encrypt(@string, @hash))
+      encryptor.encrypt(string, hash).should eq(encryptor.encrypt(string, hash))
     end
     it "creates a different string given different text" do
-      @encryptor.encrypt(@string, @hash).should_not eq(@encryptor.encrypt("anotherstring", @hash))
+      encryptor.encrypt(string, hash).should_not eq(encryptor.encrypt("anotherstring", hash))
     end
   end
-  context "decrypt" do
-    before(:each) do
-      @string = "teststring"
-      @hash = @encryptor.hash("hashstring")
-      @data = @encryptor.encrypt(@string, @hash)
-    end
+  describe "decrypt" do
+    let(:string) { "teststring" }
+    let(:hash) { encryptor.hash("hashstring") }
+    let(:data) { encryptor.encrypt(string, hash) }
+
     it "decrypts a string" do
-      @encryptor.should respond_to(:decrypt).with(2).arguments
-      @encryptor.decrypt(@data, @hash).should be_a(String)
+      encryptor.should respond_to(:decrypt).with(2).arguments
+      encryptor.decrypt(data, hash).should be_a(String)
     end
     it "decrypts an encrypted string" do
-      @encryptor.decrypt(@data, @hash).should eq(@string)
+      encryptor.decrypt(data, hash).should eq(string)
     end
   end
 end # describe PasswordSafe::Encryptor

data/spec/keyring_spec.rb

@@ -2,83 +2,74 @@ require 'spec_helper'
 require 'passwordsafe/keyring'
 
 describe PasswordSafe::Keyring do
-  before(:each) do
-    #set up a safe that will clear initilaization and send empty data
-    @safe = mock PasswordSafe::Safe
-    @safe.stub(:read_safe).and_return({})
-    @safe.stub(:write_safe)
-  end
+  let(:safe) { mock PasswordSafe::Safe, :read_safe => {}, :write_safe => nil }
+  let(:keyring) { PasswordSafe::Keyring.new(safe) }
 
   it "expects to get a Safe to read/write" do
-    @safe.should_receive(:is_a?).and_return(true)
+    safe.should_receive(:is_a?).and_return(true)
     PasswordSafe::Keyring.should respond_to(:new).with(1).argument
-    keyring = PasswordSafe::Keyring.new(@safe)
+    keyring = PasswordSafe::Keyring.new(safe)
     keyring.should have_a_safe
   end
 
-  context "length" do
+  describe "length" do
+
     it "returns the number of keys in the keyring" do
-      keyring = PasswordSafe::Keyring.new(@safe)
       keyring.should respond_to(:length)
       keyring.length.should be_a(Integer)
     end
   end
 
-  context "add" do
-    before(:each) do
-      @keyring = PasswordSafe::Keyring.new(@safe)
-    end
+  describe "add" do
+
     it "adds a key to the keyring" do
-      @keyring.should respond_to(:add).with(2).arguments
-      @keyring.add("name", "password")
-      @keyring.length.should eq(1)
+      keyring.should respond_to(:add).with(2).arguments
+      keyring.add("name", "password")
+      keyring.length.should eq(1)
     end
     it "throws an error when adding a duplicate key name" do
-      @keyring.add("name", "password")
-      expect{@keyring.add("name", "password")}.to raise_error()
+      keyring.add("name", "password")
+      expect{keyring.add("name", "password")}.to raise_error()
     end
     it "saves the modified keyring to the safe" do
-      @safe.should_receive(:write_safe).with({"name" => "password"})
-      @keyring.add("name", "password")
+      safe.should_receive(:write_safe).with({"name" => "password"})
+      keyring.add("name", "password")
     end
   end
 
-  context "get" do
+  describe "get" do
+
     it "gets a key from the keyring" do
-      @safe.stub(:read_safe).and_return({"name" => "password"})
-      @keyring = PasswordSafe::Keyring.new(@safe)
-      @keyring.get("name").should eq("password")
+      safe.stub(:read_safe).and_return({"name" => "password"})
+      keyring.get("name").should eq("password")
     end
     it "returns nil if the key does not exist" do
-      @keyring = PasswordSafe::Keyring.new(@safe)
-      @keyring.get("name").should be_nil
+      keyring.get("name").should be_nil
     end
   end
 
-  context "list" do
+  describe "list" do
+
     it "returns a list of existing key names" do
-      @safe.should_receive(:read_safe).and_return({"first" => "password", "second" => "password"})
-      @keyring = PasswordSafe::Keyring.new(@safe)
-      @keyring.list.should eq(["first", "second"])
+      safe.should_receive(:read_safe).and_return({"first" => "password", "second" => "password"})
+      keyring.list.should eq(["first", "second"])
     end
     it "returns an empty array if there are no keys" do
-      @keyring = PasswordSafe::Keyring.new(@safe)
-      @keyring.list.should eq([])
+      keyring.list.should eq([])
     end
   end
 
-  context "remove" do
+  describe "remove" do
+
     it "removes an existing key" do
-      @safe.should_receive(:read_safe).and_return({"first" => "password", "second" => "password"})
-      @keyring = PasswordSafe::Keyring.new(@safe)
-      @keyring.remove("first")
-      @keyring.get("first").should eq(nil)
+      safe.should_receive(:read_safe).and_return({"first" => "password", "second" => "password"})
+      keyring.remove("first")
+      keyring.get("first").should eq(nil)
     end
     it "saves the modified keyring to the safe" do
-      @safe.should_receive(:read_safe).and_return({"first" => "password", "second" => "password"})
-      @safe.should_receive(:write_safe).with({"second" => "password"})
-      @keyring = PasswordSafe::Keyring.new(@safe)
-      @keyring.remove("first")
+      safe.should_receive(:read_safe).and_return({"first" => "password", "second" => "password"})
+      safe.should_receive(:write_safe).with({"second" => "password"})
+      keyring.remove("first")
     end
   end
 end

data/spec/safe_spec.rb

@@ -2,67 +2,63 @@ require 'spec_helper'
 require 'passwordsafe/safe'
 
 describe PasswordSafe::Safe do
-  before (:each) do
-    @file = 'passwordsafe'
-    @filename = File.expand_path(@file)
-    @masterpass = 'masterpass'
-  end
+  let(:file) { 'passwordsafe' }
+  let(:filename) { File.expand_path(file) }
+  let(:masterpass) {'masterpass' }
+  let(:safe) { PasswordSafe::Safe.new(file, masterpass) }
 
   it "takes a safe filename and master password at initilaization" do
     PasswordSafe::Safe.should respond_to(:new).with(2).arguments
   end
 
-  context "access_safe" do
-    before(:each) do
-      @safe = PasswordSafe::Safe.new(@file, @masterpass)
-    end
+  describe "access_safe" do
+
     it "creates a safe if none exists" do
-      @safe.access_safe
-      File.file?(@filename).should be_true
+      File.delete filename if File.file?(filename)
+      safe.access_safe
+      File.file?(filename).should be_true
     end
     it "doesn't modify an existing safe" do
       content = "some existing file content"
-      File.open(@filename, 'w') {|f| f.write content}
-      @safe.access_safe
-      File.read(@filename).should eq(content)
+      File.open(filename, 'w') {|f| f.write content}
+      safe.access_safe
+      File.read(filename).should eq(content)
     end
   end
 
-  context "write_safe" do
-    before(:each) do
-      @safe = PasswordSafe::Safe.new(@file, @masterpass)
-      klass = Class.new { include PasswordSafe::Encryptor}
-      @encryptor = klass.new
-      @data = {"data" => "encrypt"}
-    end
+  context "modifying file" do
+    let(:data) { ({"data" => "encrypt"}) }
 
-    it "creates a safe file to write to" do
-      @safe.write_safe(@data)
-      File.file?(@filename).should be_true
-    end
+    describe "write_safe" do
+
+      it "creates a safe file to write to" do
+        File.delete filename if File.file?(filename)
+        safe.write_safe(data)
+        File.file?(filename).should be_true
+      end
 
-    it "writes encrypted data to a safe" do
-      @safe.write_safe(@data)
+      it "writes encrypted data to a safe" do
+        encryptor = (Class.new { include PasswordSafe::Encryptor}).new
+        safe.write_safe(data)
 
-      #we'll use our encryptor to check the contents
-      hash = @encryptor.hash(@masterpass)
-      Marshal.load(@encryptor.decrypt(File.read(@filename), hash)).should eq(@data)
+        #we'll use our encryptor to check the contents
+        hash = encryptor.hash(masterpass)
+        Marshal.load(encryptor.decrypt(File.read(filename), hash)).should eq(data)
+      end
     end
-  end
 
-  context "read_safe" do
-    it "reads encrypted data out of an existing safe" do
-      @safe = PasswordSafe::Safe.new(@file, @masterpass)
-      data = {"data" => "encrypt"}
-      @safe.write_safe(data)
-      #got data into an existing safe...now read it out again
-      @safe.read_safe.should eq(data)
+    describe "read_safe" do
+
+      it "reads encrypted data out of an existing safe" do
+        safe.write_safe(data)
+        safe.read_safe.should eq(data)
+      end
     end
   end
 
   after(:each) do
     #We check on the existance of files when we expect them to exist so this seems ok
-    File.delete @filename if File.file?(@filename)
+    File.delete filename if File.file?(filename)
   end
 end # describe PasswordSafe::Safe
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - thecatwasnot
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-23 00:00:00 -06:00
+date: 2011-01-04 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -116,6 +116,7 @@ files:
 - bin/password
 - features/add.feature
 - features/get.feature
+- features/list.feature
 - features/step_definitions/safe_steps.rb
 - features/support/env.rb
 - lib/passwordsafe.rb