pwl 0.0.2 → 0.0.3

data/lib/pwl/commands/base.rb

@@ -0,0 +1,98 @@
+module Pwl
+  module Commands
+    EXIT_CODES = {
+      :success               => Message.new('Success.'),
+      :aborted               => Message.new('Aborted by user.', 1),
+      :passwords_dont_match  => ErrorMessage.new('Passwords do not match.', 2),
+      :no_value_found        => Message.new('No value found for <%= name %>.', 3, :name => 'NAME'),
+      :file_exists           => ErrorMessage.new('There already exists a locker at <%= file %>. Use --force to overwrite it or --file to specify a different locker.', 4, :file => 'FILE'),
+      :file_not_found        => ErrorMessage.new('Locker file <%= file %> could not be found.', 5, :file => 'FILE'),
+      :name_blank            => ErrorMessage.new('Name may not be blank.', 6),
+      :value_blank           => ErrorMessage.new('Value may not be blank.', 7),
+      :list_empty            => Message.new('List is empty.', 8),
+      :list_empty_filter     => Message.new('No names found that match filter <%= filter %>.', 9, :filter => 'FILTER'),
+      :validation_new_failed => ErrorMessage.new('<%= message %>.', 10, :message => 'Validation of new master password failed'),
+      :unknown_format        => ErrorMessage.new('<%= format %> is not a known format.', 11, :format => 'FORMAT'),
+      :inaccessible_field    => ErrorMessage.new("Field '<%= field %>' is not accessible.", 12, :field => 'FIELD'),
+      :is_dir                => ErrorMessage.new('File expected, but <%= file %> is a directory. Specify a regular file for the locker.', 13, :file => 'FILE'),
+    }
+
+    class InacessibleFieldError < StandardError
+      def initialize(field)
+        super("The field #{field} is not accessible")
+      end
+    end
+
+    class Base
+      class << self
+        def exit_codes_help
+          EXIT_CODES.values.sort{|l,r| l.exit_code <=> r.exit_code}.collect{|m| "      #{m.exit_code.to_s.rjust(EXIT_CODES.size.to_s.size)}: #{m.to_s}"}.join("\n")
+        end
+
+        def default_locker_file
+          File.expand_path("~/.#{program(:name)}.pstore")
+        end
+      end
+
+    protected
+
+      def locker_file(options, init = false)
+        result = options.file || self.class.default_locker_file
+
+        if File.exists?(result) || init
+          result
+        else
+          exit_with(:file_not_found, options.verbose, :file => result)
+        end
+      end
+
+      def open_locker(options, master_password = nil)
+        # TODO Use DRb at options.url if not nil
+        locker_file = locker_file(options)
+        msg "Attempting to open locker at #{locker_file}" if options.verbose
+
+        Locker.open(locker_file, master_password || get_password("Enter the master password for #{program(:name)}:", options.gui))
+      end
+
+      def new_locker(options, master_password)
+        # Remote init not allowed. Or maybe it should be?
+        Locker.new(locker_file(options, true), master_password, {:force => options.force})
+      end
+
+      def msg(str)
+        STDERR.puts("#{program(:name)}: #{str}")
+      end
+
+      def exit_with(error_code, verbose, msg_args = {})
+        msg = EXIT_CODES[error_code]
+        raise "No message defined for error #{error_code}" if !msg
+
+        if msg.error? || verbose # always print errors; messages only when verbose
+          msg msg.to_s(msg_args)
+        end
+
+        exit(msg.exit_code)
+      end
+
+      def get_password(prompt, gui = false)
+        (gui ? Pwl::Dialog::Password.new(program(:name), prompt) : Pwl::Dialog::ConsolePasswordDialog.new(prompt)).get_input
+      end
+
+      def get_text(prompt, gui = false)
+        (gui ? Pwl::Dialog::Text.new(program(:name), prompt) : Pwl::Dialog::ConsoleTextDialog.new(prompt)).get_input
+      end
+
+      def validate!(pwd)
+        Pwl::Locker.password_policy.validate!(pwd)
+      end
+
+      #
+      # Returns the value of the passed attribute name if it is allowed to be retrieved from a locker entry
+      #
+      def attr!(entry, field)
+        raise InacessibleFieldError.new(field) unless entry.instance_variable_defined?("@#{field}".to_sym)
+        entry.send(field)
+      end
+    end
+  end
+end

data/lib/pwl/commands/delete.rb

@@ -0,0 +1,18 @@
+module Pwl
+  module Commands
+    class Delete < Base
+      def call(args, options)
+        exit_with(:name_blank, options.verbose) if 0 == args.size || args[0].blank?
+
+        begin
+          locker = open_locker(options)
+        rescue Pwl::Dialog::Cancelled
+          exit_with(:aborted, options.verbose)
+        end
+
+        locker.delete(args[0])
+        msg "Successfully deleted the value under #{args[0]}." if options.verbose
+      end
+    end
+  end
+end

data/lib/pwl/commands/export.rb

@@ -0,0 +1,22 @@
+module Pwl
+  module Commands
+    class Export < Base
+      DEFAULT_EXPORT_TEMPLATE = File.join(File.dirname(__FILE__), *%w[.. .. templates export.html.erb])
+
+      def call(args, options)
+        options.default :format => 'html'
+
+        # TODO See Stats for slightly changed approach using a method
+        presenter = {:html => Presenter::Html, :json => Presenter::Json, :yaml => Presenter::Yaml}[options.format.to_sym]
+        exit_with(:unknown_export_format, options.verbose, :format => options.format) if presenter.nil?
+
+        begin
+          locker = open_locker(options)
+          puts presenter.new(locker).to_s
+        rescue Dialog::Cancelled
+          exit_with(:aborted, options.verbose)
+        end
+      end
+    end
+  end
+end

data/lib/pwl/commands/get.rb

@@ -0,0 +1,26 @@
+module Pwl
+  module Commands
+    class Get < Base
+      def call(args, options)
+        exit_with(:name_blank, options.verbose) if 0 == args.size || args[0].blank?
+
+        # second argument can be a field other than password
+        field = args.size > 1 ? args[1] : 'password'
+
+        begin
+          locker = open_locker(options)
+          result = attr!(locker.get(args[0]), field)
+          if result.blank?
+            exit_with(:no_value_found, options.verbose, :name => args[0])
+          else
+            puts result
+          end
+        rescue InacessibleFieldError
+          exit_with(:inaccessible_field, options.verbose, :field => field)
+        rescue Dialog::Cancelled
+          exit_with(:aborted, options.verbose)
+        end
+      end
+    end
+  end
+end

data/lib/pwl/commands/init.rb

@@ -0,0 +1,35 @@
+module Pwl
+  module Commands
+    class Init < Base
+      def call(args, options)
+        locker_file = locker_file(options, true)
+        msg "Attempting to initialize new locker at #{locker_file}" if options.verbose
+
+        # Locker checks this too, but we want to fail fast.
+        exit_with(:is_dir, options.verbose, :file => locker_file) if File.exists?(locker_file) && File.directory?(locker_file)
+        exit_with(:file_exists, options.verbose, :file => locker_file) if File.exists?(locker_file) && !options.force
+
+        begin
+          begin
+            master_password = get_password('Enter new master password:', options.gui)
+          end while begin
+            validate!(master_password) # Basic idea from http://stackoverflow.com/questions/136793/is-there-a-do-while-loop-in-ruby
+          rescue Pwl::InvalidMasterPasswordError => e
+            msg e.message
+            options.gui || STDIN.tty? # only continue the loop when in interactive mode
+          end
+
+          # Ask for password confirmation if running in interactive mode (terminal)
+          if STDIN.tty? && master_password != get_password('Enter master password again:', options.gui)
+            exit_with(:passwords_dont_match, options.verbose)
+          end
+        rescue Pwl::Dialog::Cancelled
+          exit_with(:aborted, options.verbose)
+        end
+
+        new_locker(options, master_password)
+        msg "Successfully initialized new locker at #{locker_file}" if options.verbose
+      end
+    end
+  end
+end

data/lib/pwl/commands/list.rb

@@ -0,0 +1,38 @@
+module Pwl
+  module Commands
+    class List < Base
+      def call(args, options)
+        options.default :separator => ' '
+
+        begin
+          locker = open_locker(options)
+
+          if !options.long
+            result = locker.list(args[0]).join(options.separator)
+          else
+            matching_names = locker.list(args[0])
+
+            result = "total #{matching_names.size}#{$/}"
+
+            matching_names.each do |name|
+              e = locker.get(name)
+              result << "#{e.uuid}\t#{e.name}#{$/}"
+            end
+          end
+
+          if !result.blank?
+            puts result
+          else
+            if args[0] # filter given
+              exit_with(:list_empty_filter, options.verbose, args[0])
+            else
+              exit_with(:list_empty, options.verbose)
+            end
+          end
+        rescue Dialog::Cancelled
+          exit_with(:aborted, options.verbose)
+        end
+      end
+    end
+  end
+end

data/lib/pwl/commands/passwd.rb

@@ -0,0 +1,42 @@
+module Pwl
+  module Commands
+    class Passwd < Base
+      def call(args, options)
+        begin
+          locker = open_locker(options)
+
+          if !STDIN.tty? && !options.gui
+            # If we are in a pipe and do not run in GUI mode, we accept the new master password as args[0]
+            new_master_password = args[0]
+
+            begin
+              validate!(new_master_password)
+            rescue Pwl::InvalidMasterPasswordError => e
+              exit_with(:validation_new_failed, options.verbose, :message => e.message)
+            end
+          else
+            # If running interactively (console or gui), we loop until we get a valid password or break
+            begin
+              new_master_password = get_password("Enter the new master password for #{program(:name)}:", options.gui)
+            end while begin
+              validate!(new_master_password)
+            rescue Pwl::InvalidMasterPasswordError => e
+              msg e.message
+              options.gui || STDIN.tty? # only continue the loop when in interactive mode
+            end
+
+            # Confirm new password
+            if new_master_password != get_password("Enter the new master password for #{program(:name)} again:", options.gui)
+              exit_with(:passwords_dont_match, options.verbose)
+            end
+          end
+        rescue Pwl::Dialog::Cancelled
+          exit_with(:aborted, options.verbose)
+        end
+
+        locker.change_password!(new_master_password)
+        msg "Successfully changed master password for #{program(:name)}." if options.verbose
+      end
+    end
+  end
+end

data/lib/pwl/commands/stats.rb

@@ -0,0 +1,59 @@
+module Pwl
+  module Commands
+    class UnknownFormatError < StandardError; end
+
+    module StatsPresenter
+      class Text
+        def present(locker)
+          puts "Created: #{locker.created}"
+          puts "Last accessed: #{locker.last_accessed}"
+          puts "Last modified: #{locker.last_modified}"
+        end
+      end
+
+      class Html
+        def present(locker)
+          puts "TODO"
+        end
+      end
+
+      class Json
+        def present(locker)
+          puts "TODO"
+        end
+      end
+
+      class Yaml
+        def present(locker)
+          puts "TODO"
+        end
+      end
+    end
+
+    class Stats < Base
+      def call(args, options)
+        locker = open_locker(options)
+
+        begin
+          puts presenter(options.format).present(locker)
+        rescue
+          exit_with(:unknown_format, options.verbose, :format => options.format)
+        end
+      end
+
+      private
+
+      def presenter(format)
+        if !format || format.is_a?(TrueClass) || 'text' == format
+          StatsPresenter::Text.new
+        else
+          begin
+            {:html => StatsPresenter::Html, :json => StatsPresenter::Json, :yaml => StatsPresenter::Yaml}[format.to_sym].new
+          rescue
+            raise UnknownFormatError.new(format)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pwl/entry.rb

@@ -0,0 +1,31 @@
+require 'active_model'
+require 'uuid'
+
+module Pwl
+  class InvalidEntryError < StandardError
+    def initialize(errors)
+      super(errors.to_a.join(', '))
+    end
+  end
+
+  class Entry
+    attr_accessor :uuid, :name, :password
+
+    include ActiveModel::Validations
+    validates_presence_of :name, :uuid, :password
+    validates_format_of :uuid, :with => /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/
+
+    def initialize(name = nil)
+      @name = name
+      @uuid = UUID.generate
+      @password = nil
+    end
+
+    #
+    # raises InvalidEntryError if entry is not valid
+    #
+    def validate!
+      raise InvalidEntryError.new(errors) if invalid?
+    end
+  end
+end

data/lib/pwl/entry_mapper.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module Pwl
+  #
+  # DataMapper that maps an Entry from and to JSON
+  #
+  class EntryMapper
+    class << self
+      ATTRIBUTES = %w[uuid name password]
+      def from_json(str)
+        json = JSON(str, :symbolize_names => true)
+
+        Entry.new.tap do |entry|
+          ATTRIBUTES.each do |attr|
+            entry.send("#{attr}=", json[attr.to_sym])
+          end
+        end
+      end
+
+      def to_json(entry)
+        entry.validate!
+        result = {}
+        ATTRIBUTES.each do |attr|
+          result.store(attr.to_sym, entry.send(attr))
+        end
+        result.to_json
+      end
+    end
+  end
+end

data/lib/pwl/locker.rb

@@ -133,19 +133,26 @@ module Pwl
         timestamp!(:last_accessed)
         value = @backend[:user][encrypt(key)]
         raise KeyNotFoundError.new(key) unless value
-        decrypt(value)
+        EntryMapper.from_json(decrypt(value))
       }
     end
 
     #
-    # Store value stored under key
+    # Store entry or value under key
     #
-    def add(key, value)
-      raise BlankKeyError if key.blank?
-      raise BlankValueError if value.blank?
+    def add(entry_or_key, value = nil)
+      if value.nil? and entry_or_key.is_a?(Entry) # treat as entry
+        entry = entry_or_key
+      else
+        entry = Entry.new(entry_or_key)
+        entry.password = value
+      end
+
+      entry.validate!
+
       @backend.transaction{
         timestamp!(:last_modified)
-        @backend[:user][encrypt(key)] = encrypt(value)
+        @backend[:user][encrypt(entry.name)] = encrypt(EntryMapper.to_json(entry))
       }
     end
 
@@ -158,7 +165,7 @@ module Pwl
         timestamp!(:last_modified)
         old_value = @backend[:user].delete(encrypt(key))
         raise KeyNotFoundError.new(key) unless old_value
-        decrypt(old_value)
+        EntryMapper.from_json(decrypt(old_value))
       }
     end
 
@@ -178,12 +185,12 @@ module Pwl
     end
 
     #
-    # Return all entries
+    # Return all entries as array
     #
     def all
-      result = {}
+      result = []
       @backend.transaction(true){
-        @backend[:user].each{|k,v| result[decrypt(k)] = decrypt(v)}
+        @backend[:user].each{|k,v| result << EntryMapper.from_json(decrypt(v))}
       }
       result
     end
@@ -199,6 +206,7 @@ module Pwl
         # Decrypt each key and value with the old master password and encrypt them with the new master password
         copy = {}
         @backend[:user].each{|k,v|
+          # No need to (de)serialize - the value comes in as JSON and goes out as JSON
           new_key = Encryptor.encrypt(decrypt(k), :key => new_master_password)
           new_val = Encryptor.encrypt(decrypt(v), :key => new_master_password)
           copy[new_key] = new_val