uberpass 0.0.3 → 0.0.4

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+password.txt

data/README.rdoc

@@ -9,12 +9,22 @@
   $ openssl genrsa -des3 -out ~/.uberpass/private.pem 2048
   $ openssl rsa -in ~/.uberpass/private.pem -out ~/.uberpass/public.pem -outform PEM -pubout
 
+== Dropbox
+
+  $ mv ~/.uberpass ~/Dropbox/uberpass
+  $ ln -s ~/Dropbox/uberpass ~/.uberpass
+
 == Use
 
-You personal passwords:
+Your personal passwords:
 
   $ uberpass
 
 or your work related passwords:
 
   $ uberpass happy_place
+
+and getting some help:
+
+  $ uberpass
+  $ uberpass:0.0.4> help

data/lib/uberpass.rb

@@ -1,314 +1,11 @@
-require 'uberpass/version'
 require 'openssl'
 require 'yaml'
-require 'ostruct'
-require 'securerandom'
-
-module Uberpass
-  class Decrypt
-    attr_reader :decrypted_data
-
-    def initialize(private_key, encrypted_data, encrypted_key, encrypted_iv)
-      key = OpenSSL::PKey::RSA.new(private_key)
-      cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
-      cipher.decrypt
-      cipher.key = key.private_decrypt(encrypted_key)
-      cipher.iv = key.private_decrypt(encrypted_iv)
-
-      @decrypted_data = cipher.update(encrypted_data)
-      @decrypted_data << cipher.final
-    end
-  end
-
-  class Encrypt
-    attr_reader :encrypted_data, :encrypted_key, :encrypted_iv
-
-    def initialize(public_key, decrypted_data)
-      key = OpenSSL::PKey::RSA.new(public_key)
-      cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
-      cipher.encrypt
-      cipher.key = random_key = cipher.random_key
-      cipher.iv = random_iv = cipher.random_iv
-
-      @encrypted_data = cipher.update(decrypted_data)
-      @encrypted_data << cipher.final
-
-      @encrypted_key =  key.public_encrypt(random_key)
-      @encrypted_iv = key.public_encrypt(random_iv)
-    end
-  end
- 
-  class FileHandler
-    class << self
-      attr_accessor :namespace
-       
-      def configure
-        yield self
-      end
-      
-      def name_spaced_file(file_name)
-        @namespace.nil? ? file_name : "#{file_name}_#{@namespace}"
-      end
-
-      def private_key_file
-        File.expand_path("~/.uberpass/private.pem")
-      end
-
-      def public_key_file
-        File.expand_path("~/.uberpass/public.pem")
-      end
-
-      def passwords_file
-        File.expand_path("~/.uberpass/#{name_spaced_file("passwords")}")
-      end
-
-      def key_file
-        File.expand_path("~/.uberpass/#{name_spaced_file("key")}")
-      end
-      
-      def iv_file
-        File.expand_path("~/.uberpass/#{name_spaced_file("iv")}")
-      end
-
-      def write(encryptor)
-        File.open(passwords_file, "w") { |file|
-          file.write(encryptor.encrypted_data)
-        }
-        File.open(key_file, "w") { |file|
-          file.write(encryptor.encrypted_key)
-        }
-        File.open(iv_file, "w") { |file|
-          file.write(encryptor.encrypted_iv)
-        }
-      end
-
-      def decrypted_passwords
-        if File.exists?(passwords_file)
-          YAML::load(
-            Decrypt.new(
-              File.read(private_key_file),
-              File.read(passwords_file),
-              File.read(key_file),
-              File.read(iv_file)
-            ).decrypted_data
-          )
-        else
-          {}
-        end
-      end
-
-      def show(key)
-        Hash[*[key, decrypted_passwords[key]]]
-      end
-
-      def all
-        decrypted_passwords.map do |entry|
-          Hash[*entry]
-        end
-      end
-
-      def generate_short(key)
-        encrypt key, SecureRandom.urlsafe_base64(8)
-      end
-
-      def generate(key)
-        encrypt key, SecureRandom.urlsafe_base64(24)
-      end
-
-      def encrypt(key, password)
-        passwords = decrypted_passwords
-        entry = passwords[key] = {
-          "password" => password,
-          "created_at" => Time.now
-        }
-        encryptor = Encrypt.new(File.read(public_key_file), passwords.to_yaml)
-        write(encryptor)
-        Hash[*[key, entry]]
-      end
-
-      def rename(old, new)
-        passwords = decrypted_passwords
-        entry = passwords.delete old
-        passwords[new] = entry
-        encryptor = Encrypt.new(File.read(public_key_file), passwords.to_yaml)
-        write(encryptor)
-        Hash[*[new, entry]]
-      end
-
-      def destroy(key)
-        passwords = decrypted_passwords
-        entry = passwords.delete key
-        encryptor = Encrypt.new(File.read(public_key_file), passwords.to_yaml)
-        write(encryptor)
-        Hash[*[key, entry]]
-      end
-        
-    end
-  end
-
-  class CLI
-    class InvalidActionError < StandardError; end
-    class MissingArgumentError < StandardError; end
-
-    module Actions
-      attr_accessor :actions
 
-      def register_action(*args, &block)
-        options           = args.size == 1 ? {} : (args.last || {})
-        options[:short]   = options[:short].nil? ? args.first[0] : options.delete(:short).to_s
-        options[:steps]   = [] if options[:steps].nil?
-        options[:filter] = [] if options[:filter].nil?
-        options[:confirm] = false if options[:confirm].nil?
-        (@actions ||= []) << OpenStruct.new({ :name => args.first, :proc => block }.merge(options))
-      end
-    end
-
-    module Formater
-      def bold(obj)
-        "\033[0;1m#{obj}\033[0m"
-      end
-
-      def red(obj)
-        "\033[01;31m#{obj}\033[0m"
-      end
-
-      def green(obj)
-        "\033[0;32m#{obj}\033[0m"
-      end
-    
-      def gray(obj)
-        "\033[1;30m#{obj}\033[0m"
-      end
-    end
-
-    extend Actions
-    include Formater
-
-    register_action :generate, :steps => ["key"] do |key|
-      FileHandler.generate key
-    end
-
-    register_action :generate_short, :steps => ["key"], :short => :gs do |key|
-      FileHandler.generate_short key
-    end
-
-    register_action :destroy, :steps => ["key"], :short => :rm, :confirm => true do |key|
-      FileHandler.destroy key
-    end
-
-    register_action :show, :steps => ["key"] do |key|
-      FileHandler.show key
-    end
-
-    register_action :encrypt, :steps => ["key", "password"] do |key, password|
-      FileHandler.encrypt key, password
-    end
-
-    register_action :rename, :steps => ["key", "new name"] do |old, new|
-      FileHandler.rename old, new
-    end
-
-    register_action :list, :filter => ["password"] do
-      FileHandler.all
-    end
-
-    register_action :dump do
-      FileHandler.all
-    end
-
-    register_action :help do
-      CLI.help
-      []
-    end
-
-    register_action :exit, :short => :ex do
-      exit
-    end
-
-    def initialize(namespace)
-      FileHandler.configure do |handler|
-        handler.namespace = namespace
-      end
-      line
-      do_action
-    end
-
-    def line(message = nil, format = :bold)
-      parts = []
-      parts << "\nuberpass"
-      parts << "#{VERSION}:"
-      parts << send(format, message) unless message.nil?
-      parts << "> "
-      print parts.join(' ')
-    end
-
-    def self.help
-      print "\nactions:\n"
-      actions.each do |action|
-        print "  #{action.name}\n"
-      end
-    end
-
-    def confirm_action
-      line "are you sure you? [yn]", :green
-      $stdin.gets.chomp == "y"
-    end
-
-    def do_action
-      input = $stdin.gets.chomp
-      do_action_with_rescue input
-    end
-
-    def do_action_with_rescue(input)
-      args = input.split(/ /)
-      begin
-        action = fetch_action args.slice!(0)
-        action.steps[args.size, action.steps.size].each do |instruction|
-          line instruction, :green
-          arg = $stdin.gets.chomp
-          raise MissingArgumentError, instruction if arg == ""
-          args << arg
-        end 
-        if action.confirm
-          pp(action.proc.call(*args), action.filter) if confirm_action
-        else
-          pp(action.proc.call(*args), action.filter)
-        end
-        print "\n"
-        line
-        do_action
-      rescue MissingArgumentError => e
-        line e, :red
-        do_action
-      rescue InvalidActionError => e
-        line e, :red
-        do_action
-      rescue OpenSSL::PKey::RSAError => e
-        line e, :red
-        do_action
-      end
-    end
-
-    def fetch_action(key)
-      self.class.actions.each do |action|
-        return action if action.name == key.to_sym || action.short == key
-      end
-      raise InvalidActionError, key
-    end
+require 'uberpass/version'
+require 'uberpass/decrypt'
+require 'uberpass/encrypt'
+require 'uberpass/file_handler'
+require 'uberpass/cli'
 
-    def pp(entry, filter)
-      if entry.is_a? Array
-        entry.each do |entry|
-          pp entry, filter
-        end
-      else
-        key = entry.keys.first
-        filter.each do |f|
-          entry[key].delete f
-        end
-        print "\n#{gray entry[key]["created_at"].strftime("%d/%m/%Y")} #{bold key} "
-        print "\n#{entry[key]["password"]}" unless entry[key]["password"].nil?
-      end
-    end
-  end
+module Uberpass
 end

data/lib/uberpass/cli.rb

@@ -0,0 +1,284 @@
+require 'ostruct'
+require "highline"
+
+module Uberpass
+  class CLI
+    class InvalidActionError < StandardError
+      attr_reader :action
+
+      def initialize action
+        @action = action
+        super
+      end
+
+      def to_s
+        "\\'#{action}\\' is not a uberpass command"
+      end
+    end
+
+    class MissingArgumentError < StandardError; end
+
+    module Actions
+      class Register
+        attr_accessor :name, :short, :usage, :description, :confirm
+        attr_writer :proc
+
+        def call *args
+          @proc.call *args
+        end
+      end
+
+      attr_accessor :actions
+
+      def register_action
+        register = Register.new
+        yield register
+        (@actions ||= []) << register
+      end
+    end
+
+    HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+      cs[:error]   = [:bold, :red]
+      cs[:confirm] = [:green]
+      cs[:date]    = [:white]
+      cs[:name]    = [:bold]
+      cs[:index]   = [:magenta]
+    end
+
+    extend Actions
+
+    register_action do |action|
+      action.name        = 'help'
+      action.short       = 'help'
+      action.usage       = 'help'
+      action.proc        = ->(terminal) {
+        HelpDecorator.new(terminal, self.actions).output
+      }
+      action.description = "Lists all commands"
+    end
+
+    register_action do |action|
+      action.name        = 'generate'
+      action.short       = 'g'
+      action.usage       = 'g google'
+      action.proc        = ->(terminal, key) {
+        ShowDecorator.new(terminal, FileHandler.generate(key)).output
+      }
+      action.description = "Generates a random password for a given key"
+    end
+
+    register_action do |action|
+      action.name        = 'generate_short'
+      action.short       = 'gs'
+      action.usage       = 'gs [name]'
+      action.proc        = ->(terminal, key) {
+        ShowDecorator.new(terminal, FileHandler.generate_short(key)).output
+      }
+      action.description = "Generates a random password but smaller so its easier to type into a phone or a legacy system"
+    end
+
+    register_action do |action|
+      action.name        = 'remove'
+      action.short       = 'rm'
+      action.usage       = 'rm [name]'
+      action.confirm     = true
+      action.proc        = ->(terminal, key) {
+        ShowDecorator.new(terminal, FileHandler.remove(key)).output
+      }
+      action.description = "Removes and entry"
+    end
+
+    register_action do |action|
+      action.name        = 'show'
+      action.short       = 's'
+      action.usage       = 's [name|index]'
+      action.proc        = ->(terminal, key) {
+        entry = if key =~ /^\d+$/
+          FileHandler.all[key.to_i]
+        else
+          FileHandler.show key
+        end
+        ShowDecorator.new(terminal, entry).output
+      }
+      action.description = "Shows an entry"
+    end
+
+    register_action do |action|
+      action.name        = 'encrypt'
+      action.short       = 'e'
+      action.usage       = '[name] << [password]'
+      action.proc        = ->(terminal, key, password) {
+        ShowDecorator.new(terminal, FileHandler.encrypt(key, password)).output
+      }
+      action.description = "Encrypts a value"
+    end
+
+    register_action do |action|
+      action.name        = 'rename'
+      action.short       = 'mv'
+      action.usage       = 'mv [name] [new name]'
+      action.proc        = ->(terminal, old, new) {
+        ShowDecorator.new(terminal, FileHandler.rename(old, new)).output
+      }
+      action.description = "Rename an entry"
+    end
+
+    register_action do |action|
+      action.name        = 'list'
+      action.short       = 'ls'
+      action.usage       = 'ls'
+      action.proc        = ->(terminal) {
+        ListDecorator.new(terminal, FileHandler.all).output
+      }
+      action.description = "Lists all entries"
+    end
+
+    register_action do |action|
+      action.name        = 'dump'
+      action.short       = 'dump'
+      action.usage       = 'dump'
+      action.proc        = ->(terminal) {
+        DumpDecorator.new(terminal, FileHandler.all).output
+      }
+      action.description = "Dumps all entries including passwords"
+    end
+
+    def initialize(namespace, input = $stdin, output = $stdout, run_loop = true)
+      @input    = input
+      @output   = output
+      @run_loop = run_loop
+      @terminal = HighLine.new @input, @output
+
+      pass = @terminal.ask("Enter PEM pass phrase: ") { |q| q.echo = '*' }
+      @output.print "\n"
+
+      FileHandler.configure do |handler|
+        handler.namespace = namespace
+        handler.pass_phrase = pass
+      end
+      do_action if @run_loop
+    end
+
+    def self.help
+      print "\nactions:\n"
+      actions.each do |action|
+        @output.print "  #{action.name}\n"
+      end
+    end
+
+    def confirm_action
+      @terminal.agree("<%= color('are you sure?', :confirm) %> ") { |q| q.default = "n" }
+    end
+
+    def do_action
+      input = @terminal.ask "uberpass:#{VERSION}> "
+      return if input.strip == 'exit'
+      @output.print "\n"
+      do_action_with_rescue input
+      @output.print "\n"
+      do_action if @run_loop
+    end
+
+    def do_action_with_rescue(input)
+      args = input.split(/ /).compact
+      if args[1] == '<'
+        action = fetch_action 'encrypt'
+        args.slice!(1)
+      else
+        action = fetch_action args.slice!(0)
+      end
+
+      if action.confirm && @run_loop
+        action.call(@terminal, *args) if confirm_action
+      else
+        action.call(@terminal, *args)
+      end
+    rescue MissingArgumentError, InvalidActionError, OpenSSL::PKey::RSAError => e
+      @terminal.say "<%= color('#{e}', :error) %>"
+    rescue FileHandler::ExistingEntryError => key
+      @terminal.say "<%= color('#{key} is already defined, try removing it first', :error) %>"
+    end
+
+    def fetch_action(key)
+      self.class.actions.each do |action|
+        return action if action.name == key || action.short == key
+      end
+      raise InvalidActionError, key
+    end
+
+    class ListDecorator
+      def initialize terminal, entries
+        @terminal, @entries = terminal, entries
+      end
+
+      def output
+        @entries.each_with_index do |entry, index|
+          key = entry.keys.first
+          output_entry key, entry[key], index
+        end
+      end
+
+      def output_entry(key, values, index)
+        out = "<%= color('#{values["created_at"].strftime("%d/%m/%Y")}', :date) %>"
+        out << " <%= color('[#{index}]', :index) %>"
+        out << " <%= color('#{key}', :name) %>"
+        @terminal.say out
+      end
+    end
+
+    class DumpDecorator < ListDecorator
+      def initialize terminal, entries
+        @terminal, @entries = terminal, entries
+      end
+
+      def output
+        @entries.each do |entry|
+          key = entry.keys.first
+          output_entry key, entry[key]
+        end
+      end
+
+      def output_entry(key, value)
+        out = "<%= color('#{key}', :name) %>"
+        out << " #{value["password"]}"
+        @terminal.say out
+      end
+    end
+
+    class ShowDecorator
+      def initialize terminal, entry
+        @terminal, @entry = terminal, entry
+      end
+
+      def output
+        key = @entry.keys.first
+        output_entry key, @entry[key]
+      end
+
+      def output_entry(key, values)
+        out = "<%= color('#{values["created_at"].strftime("%d/%m/%Y")}', :date) %>"
+        out << " <%= color('#{key}', :name) %>\n"
+        out << "<%= color('#{values["password"]}', :name) %>"
+
+        @terminal.say out
+      end
+    end
+
+    class HelpDecorator
+      def initialize terminal, actions
+        @terminal, @actions = terminal, actions
+      end
+
+      def output
+        @actions.each do |action|
+          next if action.name == 'help'
+          @terminal.say <<HELP
+<%= color('#{action.name} -  #{action.description}', BOLD) %> 
+usage: #{action.usage}
+
+HELP
+        end
+      end
+    end
+  end
+end

data/lib/uberpass/decrypt.rb

@@ -0,0 +1,18 @@
+require 'openssl'
+
+module Uberpass
+  class Decrypt
+    attr_reader :decrypted_data
+
+    def initialize(private_key, encrypted_data, encrypted_key, encrypted_iv, pass_phrase = nil)
+      key = OpenSSL::PKey::RSA.new(private_key, pass_phrase)
+      cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
+      cipher.decrypt
+      cipher.key = key.private_decrypt(encrypted_key)
+      cipher.iv = key.private_decrypt(encrypted_iv)
+
+      @decrypted_data = cipher.update(encrypted_data)
+      @decrypted_data << cipher.final
+    end
+  end
+end

data/lib/uberpass/encrypt.rb

@@ -0,0 +1,21 @@
+require 'openssl'
+
+module Uberpass
+  class Encrypt
+    attr_reader :encrypted_data, :encrypted_key, :encrypted_iv
+
+    def initialize(public_key, decrypted_data, pass_phrase = nil)
+      key = OpenSSL::PKey::RSA.new(public_key, pass_phrase)
+      cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
+      cipher.encrypt
+      cipher.key = random_key = cipher.random_key
+      cipher.iv = random_iv = cipher.random_iv
+
+      @encrypted_data = cipher.update(decrypted_data)
+      @encrypted_data << cipher.final
+
+      @encrypted_key =  key.public_encrypt(random_key)
+      @encrypted_iv = key.public_encrypt(random_iv)
+    end
+  end
+end

data/lib/uberpass/file_handler.rb

@@ -0,0 +1,115 @@
+require 'securerandom'
+
+module Uberpass
+  class FileHandler
+    class ExistingEntryError < StandardError; end
+
+    class << self
+      attr_accessor :namespace, :pass_phrase
+
+      def configure
+        yield self
+      end
+
+      def name_spaced_file(file_name)
+        @namespace.nil? ? file_name : "#{file_name}_#{@namespace}"
+      end
+
+      def private_key_file
+        File.expand_path("~/.uberpass/private.pem")
+      end
+
+      def public_key_file
+        File.expand_path("~/.uberpass/public.pem")
+      end
+
+      def passwords_file
+        File.expand_path("~/.uberpass/#{name_spaced_file("passwords")}")
+      end
+
+      def key_file
+        File.expand_path("~/.uberpass/#{name_spaced_file("key")}")
+      end
+      
+      def iv_file
+        File.expand_path("~/.uberpass/#{name_spaced_file("iv")}")
+      end
+
+      def write(encryptor)
+        File.open(passwords_file, "w") { |file|
+          file.write(encryptor.encrypted_data)
+        }
+        File.open(key_file, "w") { |file|
+          file.write(encryptor.encrypted_key)
+        }
+        File.open(iv_file, "w") { |file|
+          file.write(encryptor.encrypted_iv)
+        }
+      end
+
+      def decrypted_passwords
+        if File.exists?(passwords_file)
+          YAML::load(
+            Decrypt.new(
+              File.read(private_key_file),
+              File.read(passwords_file),
+              File.read(key_file),
+              File.read(iv_file),
+              pass_phrase
+            ).decrypted_data
+          )
+        else
+          {}
+        end
+      end
+
+      def show(key)
+        Hash[*[key, decrypted_passwords[key]]]
+      end
+
+      def all
+        decrypted_passwords.map do |entry|
+          Hash[*entry]
+        end
+      end
+
+      def generate_short(key)
+        encrypt key, SecureRandom.urlsafe_base64(8)
+      end
+
+      def generate(key)
+        encrypt key, SecureRandom.urlsafe_base64(24)
+      end
+
+      def encrypt(key, password)
+        passwords = decrypted_passwords
+        raise ExistingEntryError, key unless passwords[key].nil?
+        entry = passwords[key] = {
+          "password" => password,
+          "created_at" => Time.now
+        }
+        encryptor = Encrypt.new(File.read(public_key_file), passwords.to_yaml, pass_phrase)
+        write(encryptor)
+        Hash[*[key, entry]]
+      end
+
+      def rename(old, new)
+        passwords = decrypted_passwords
+        raise ExistingEntryError, new unless passwords[new].nil?
+        entry = passwords.delete old
+        passwords[new] = entry
+        encryptor = Encrypt.new(File.read(public_key_file), passwords.to_yaml)
+        write(encryptor)
+        Hash[*[new, entry]]
+      end
+
+      def remove(key)
+        passwords = decrypted_passwords
+        entry = passwords.delete key
+        encryptor = Encrypt.new(File.read(public_key_file), passwords.to_yaml)
+        write(encryptor)
+        Hash[*[key, entry]]
+      end
+    end
+  end
+end

data/lib/uberpass/version.rb

@@ -1,3 +1,3 @@
 module Uberpass
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/uberpass_output.rb

@@ -0,0 +1,58 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$password = File.read(File.join(File.dirname(__FILE__), '..', 'password.txt')).strip
+$password.freeze
+
+require 'uberpass'
+
+input  = StringIO.new
+output = StringIO.new
+
+input << $password
+input.rewind
+
+uberpass = Uberpass::CLI.new 'test', input, output, false
+
+input.truncate input.rewind
+
+puts output.string
+output.truncate output.rewind
+
+input << 'ls'
+input.rewind
+uberpass.do_action
+input.truncate input.rewind
+
+puts output.string
+output.truncate output.rewind
+
+input << 'dump'
+input.rewind
+uberpass.do_action
+input.truncate input.rewind
+
+puts output.string
+output.truncate output.rewind
+
+input << 'g cia'
+input.rewind
+uberpass.do_action
+input.truncate input.rewind
+
+puts output.string
+output.truncate output.rewind
+
+input << 's cia'
+input.rewind
+uberpass.do_action
+input.truncate input.rewind
+
+puts output.string
+output.truncate output.rewind
+
+input << 'help'
+input.rewind
+uberpass.do_action
+input.truncate input.rewind
+
+puts output.string
+output.truncate output.rewind

data/spec/uberpass_spec.rb

@@ -0,0 +1,119 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$password = File.read(File.join(File.dirname(__FILE__), '..', 'password.txt')).strip
+$password.freeze
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'turn/autorun'
+require 'uberpass'
+
+describe Uberpass do
+  before do
+    @input    = StringIO.new
+    @output   = StringIO.new
+
+    @input << $password
+    @input.rewind
+
+    @uberpass = Uberpass::CLI.new 'test', @input, @output, false
+
+    @input.truncate(@input.rewind)
+
+    Uberpass::FileHandler.all.each do |entry|
+      Uberpass::FileHandler.remove entry.keys.first
+    end
+
+    Uberpass::FileHandler.generate 'twitter'
+    Uberpass::FileHandler.generate 'facebook'
+  end
+
+  it "should ask and memorise the password" do
+    prompt = "Enter PEM pass phrase: #{$password.gsub(/\w/, '*')}\n\n"
+
+    assert_equal prompt, @output.string
+    assert_equal $password, Uberpass::FileHandler.pass_phrase
+  end
+
+  it "should list entries" do
+    @output.truncate(@output.rewind)
+    @input << 'ls'
+    @input.rewind
+
+    @uberpass.do_action
+
+    assert_match /facebook/, @output.string
+    assert_match /twitter/, @output.string
+    assert_match Time.now.strftime("%d/%m/%Y"), @output.string
+  end
+
+  it "should raise and catch argument error" do
+    @output.truncate(@output.rewind)
+    @input << 'wadyawant'
+    @input.rewind
+
+    @uberpass.do_action
+
+    assert_match /is not a uberpass command/, @output.string
+    assert_match /'wadyawant'/, @output.string
+  end
+
+  it "should confirm deletion of password" do
+    Uberpass::FileHandler.generate 'linkedin'
+
+    @output.truncate(@output.rewind)
+    @input << 'rm linkedin'
+    @input.rewind
+
+    @uberpass.do_action
+
+    @input.truncate(@input.rewind)
+    @input << 'yes'
+    @input.rewind
+
+    @uberpass.confirm_action
+
+    assert_match /are you sure\?/, @output.string
+    assert_match /linkedin/, @output.string
+    assert_match Time.now.strftime("%d/%m/%Y"), @output.string
+  end
+
+  it "should encrypt an existing password with <" do
+    @output.truncate(@output.rewind)
+    @input << 'google < xxx'
+    @input.rewind
+
+    @uberpass.do_action
+
+    password = Uberpass::FileHandler.show 'google'
+
+    refute_nil password['google']['password']
+  end
+
+  it "should encrypt an existing password with <" do
+    @output.truncate(@output.rewind)
+    @input << 'e foursquare xxx'
+    @input.rewind
+
+    @uberpass.do_action
+
+    password = Uberpass::FileHandler.show 'foursquare'
+
+    refute_nil password['foursquare']['password']
+  end
+
+  it "should rename a key" do
+    Uberpass::FileHandler.generate 'tumbler'
+
+    @output.truncate(@output.rewind)
+    @input << 'mv tumbler tumblr'
+    @input.rewind
+
+    @uberpass.do_action
+
+    password = Uberpass::FileHandler.show 'tumbler'
+    assert_nil password['tumbler']
+
+    password = Uberpass::FileHandler.show 'tumblr'
+    refute_nil password['tumblr']
+  end
+end

data/uberpass.gemspec

@@ -13,7 +13,9 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "uberpass"
 
+  s.add_runtime_dependency "highline", "1.6.15"
   s.add_development_dependency "rake"
+  s.add_development_dependency "turn", "0.9.6"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uberpass
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,56 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-09 00:00:00.000000000 Z
+date: 2013-03-03 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.15
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70366937140340 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.6
   type: :development
   prerelease: false
-  version_requirements: *70366937140340
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.6
 description: uses open ssl and a cli to generate and retrieve passwords
 email:
 - rufuspost@gmail.com
@@ -36,7 +73,13 @@ files:
 - Rakefile
 - bin/uberpass
 - lib/uberpass.rb
+- lib/uberpass/cli.rb
+- lib/uberpass/decrypt.rb
+- lib/uberpass/encrypt.rb
+- lib/uberpass/file_handler.rb
 - lib/uberpass/version.rb
+- spec/uberpass_output.rb
+- spec/uberpass_spec.rb
 - uberpass.gemspec
 homepage: ''
 licenses: []
@@ -50,22 +93,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4545846251252195404
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4545846251252195404
 requirements: []
 rubyforge_project: uberpass
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: command line key chain
-test_files: []
+test_files:
+- spec/uberpass_output.rb
+- spec/uberpass_spec.rb
+has_rdoc: