keyrack 0.3.0.pre → 0.3.0

data/lib/keyrack/event.rb

@@ -0,0 +1,13 @@
+module Keyrack
+  class Event
+    attr_reader :owner, :name, :parent
+    attr_accessor :attribute_name, :previous_value, :new_value,
+      :collection_name, :object
+
+    def initialize(owner, name, parent = nil)
+      @owner = owner
+      @name = name
+      @parent = parent
+    end
+  end
+end

data/lib/keyrack/exceptions.rb

@@ -0,0 +1,4 @@
+module Keyrack
+  class SiteError < Exception; end
+  class GroupError < Exception; end
+end

data/lib/keyrack/group.rb

@@ -0,0 +1,225 @@
+module Keyrack
+  class Group < Hash
+    def initialize(arg = nil)
+      case arg
+      when String
+        self['name'] = arg
+        self['sites'] = []
+        self['groups'] = {}
+      when Hash
+        load(arg)
+      when nil
+        @uninitialized = true
+      end
+
+      @after_event = []
+    end
+
+    def load(hash)
+      @loading = true
+
+      if !hash.has_key?('name')
+        raise ArgumentError, "hash is missing the 'name' key"
+      end
+      if !hash['name'].is_a?(String)
+        raise ArgumentError, "name is not a String"
+      end
+      self['name'] = hash['name']
+
+      if !hash.has_key?('sites')
+        raise ArgumentError, "hash is missing the 'sites' key"
+      end
+      if !hash['sites'].is_a?(Array)
+        raise ArgumentError, "sites is not an Array"
+      end
+
+      if !hash.has_key?('groups')
+        raise ArgumentError, "hash is missing the 'groups' key"
+      end
+      if !hash['groups'].is_a?(Hash)
+        raise ArgumentError, "groups is not a Hash"
+      end
+
+      self['sites'] = []
+      hash['sites'].each_with_index do |site_hash, site_index|
+        if !site_hash.is_a?(Hash)
+          raise ArgumentError, "site #{site_index} is not a Hash"
+        end
+
+        begin
+          site = Site.new(site_hash)
+          add_site_without_callbacks(site)
+        rescue SiteError => e
+          raise ArgumentError, "site #{site_index} is not valid: #{e.message}"
+        end
+      end
+
+      self['groups'] = {}
+      hash['groups'].each_pair do |group_name, group_hash|
+        if !group_name.is_a?(String)
+          raise ArgumentError, "group key is not a String"
+        end
+        if !group_hash.is_a?(Hash)
+          raise ArgumentError, "group value for #{group_name.inspect} is not a Hash"
+        end
+
+        begin
+          group = Group.new(group_hash)
+          add_group_without_callbacks(group)
+        rescue ArgumentError => e
+          raise ArgumentError, "group #{group_name.inspect} is not valid: #{e.message}"
+        end
+
+        if group.name != group_name
+          raise ArgumentError, "group name mismatch: #{group_name.inspect} != #{group.name.inspect}"
+        end
+      end
+
+      @loading = false
+      @uninitialized = false
+    end
+
+    def change_attribute(name, value)
+      event = Event.new(self, 'change')
+      event.attribute_name = name
+      event.previous_value = self[name]
+      event.new_value = value
+
+      self[name] = value
+      trigger(event)
+    end
+
+    def name
+      self['name']
+    end
+
+    def name=(name)
+      change_attribute('name', name)
+    end
+
+    def sites
+      self['sites']
+    end
+
+    def groups
+      self['groups']
+    end
+
+    def add_site(site)
+      raise "add_site is not allowed until Group is initialized" if @uninitialized && !@loading
+      add_site_without_callbacks(site)
+
+      event = Event.new(self, 'add')
+      event.collection_name = 'sites'
+      event.object = site
+      trigger(event)
+    end
+
+    def site(index)
+      sites[index]
+    end
+
+    def remove_site(site)
+      raise "remove_site is not allowed until Group is initialized" if @uninitialized && !@loading
+      index = sites.index(site)
+      if index.nil?
+        raise GroupError, "site doesn't exist"
+      end
+      site = sites.delete_at(index)
+
+      event = Event.new(self, 'remove')
+      event.collection_name = 'sites'
+      event.object = site
+      trigger(event)
+    end
+
+    def add_group(group)
+      raise "add_group is not allowed until Group is initialized" if @uninitialized && !@loading
+      add_group_without_callbacks(group)
+
+      event = Event.new(self, 'add')
+      event.collection_name = 'groups'
+      event.object = group
+      trigger(event)
+    end
+
+    def remove_group(group_name)
+      raise "remove_group is not allowed until Group is initialized" if @uninitialized && !@loading
+      if !groups.has_key?(group_name)
+        raise GroupError, "group doesn't exist"
+      end
+      group = groups.delete(group_name)
+
+      event = Event.new(self, 'remove')
+      event.collection_name = 'groups'
+      event.object = group
+      trigger(event)
+    end
+
+    def group(group_name)
+      groups[group_name]
+    end
+
+    def group_names
+      groups.keys
+    end
+
+    def after_event(&block)
+      @after_event << block
+    end
+
+    def encode_with(coder)
+      coder.represent_map(nil, self)
+    end
+
+    private
+
+    def add_site_without_callbacks(site)
+      if !site.is_a?(Site)
+        raise GroupError, "site is not a Site"
+      end
+      if sites.include?(site)
+        raise GroupError,
+          "site (#{site.name.inspect}, #{site.username.inspect}) already exists"
+      end
+      sites << site
+      add_site_hooks_for(site)
+    end
+
+    def add_group_without_callbacks(group)
+      if !group.is_a?(Group)
+        raise GroupError, "group is not a Group"
+      end
+      if groups.has_key?(group.name)
+        raise GroupError, "group already exists"
+      end
+      groups[group.name] = group
+      add_group_hooks_for(group)
+    end
+
+    def trigger(event)
+      @after_event.each do |block|
+        block.call(event)
+      end
+    end
+
+    def add_site_hooks_for(site)
+      site.after_event do |site_event|
+        trigger(Event.new(self, 'change', site_event))
+      end
+    end
+
+    def add_group_hooks_for(group)
+      group.after_event do |group_event|
+        if group_event.name == 'change' && group_event.attribute_name == 'name'
+          key, value = self.groups.find { |(k, v)| v.equal?(group) }
+          if key
+            self['groups'][group.name] = self['groups'].delete(key)
+          end
+        end
+
+        trigger(Event.new(self, 'change', group_event))
+      end
+    end
+  end
+end

data/lib/keyrack/migrator.rb

@@ -0,0 +1,45 @@
+module Keyrack
+  # Migrate databases from one version to the next.
+  class Migrator
+    def self.run(database)
+      new(database).run
+    end
+
+    def initialize(database)
+      @database = database
+      @version = database['version']
+    end
+
+    def run
+      case @version
+      when 3
+        migrate_3_to_4(@database.clone)
+      when 4
+        @database
+      end
+    end
+
+    private
+
+    def migrate_3_to_4(database)
+      groups = [database['groups']['top']]
+      until groups.empty?
+        group = groups.pop
+        group['sites'] =
+          group['sites'].inject([]) do |arr, (site_name, site_hash)|
+            site_hash['logins'].each_pair do |username, password|
+              arr.push({
+                'name' => site_name,
+                'username' => username,
+                'password' => password
+              })
+            end
+          arr
+        end
+        groups.push(*group['groups'].values)
+      end
+      database['version'] = 4
+      database
+    end
+  end
+end

data/lib/keyrack/runner.rb

@@ -1,81 +1,135 @@
 module Keyrack
   class Runner
     def initialize(argv)
-      @config_path = "~/.keyrack"
-      OptionParser.new do |opts|
-        opts.on("-d", "--directory [PATH]", "Specify configuration path (Default: #{@config_path}") do |f|
-          @config_path = f
+      opts = { :path => "~/.keyrack" }
+      OptionParser.new do |optparse|
+        optparse.on("-d", "--directory [PATH]", "Specify configuration path (Default: #{@config_path}") do |path|
+          opts[:path] = path
         end
       end.parse(argv)
-      @config_path = File.expand_path(@config_path)
+      @config_path = File.expand_path(opts[:path])
       @ui = UI::Console.new
 
+      database_exists = false
       if Dir.exist?(@config_path)
-        @options = YAML.load_file(File.join(@config_path, "config"))
-        password = @ui.get_password
-        rsa_key = Utils.open_rsa_key(File.expand_path(@options['rsa'], @config_path), password)
-        aes_data = Utils.open_aes_data(File.expand_path(@options['aes'], @config_path), rsa_key)
-      else
-        Dir.mkdir(@config_path)
+        config_filename = File.join(@config_path, "config.yml")
+        if File.exist?(config_filename)
+          database_exists = true
+          @options = YAML.load_file(config_filename)
+          password = @ui.get_password
+        end
+      end
+
+      if !database_exists
+        FileUtils.mkdir_p(@config_path)
         @options = {}
         @ui.display_first_time_notice
 
-        # RSA
-        rsa_options = @ui.rsa_setup
-        rsa_key, rsa_pem = Utils.generate_rsa_key(rsa_options['password'])
-        rsa_path = File.expand_path(rsa_options['path'], @config_path)
-        File.open(rsa_path, 'w') { |f| f.write(rsa_pem) }
-        @options['rsa'] = rsa_path
-
-        # AES
-        aes_data = {
-          'key' => Utils.generate_aes_key,
-          'iv'  => Utils.generate_aes_key
-        }
-        dump = Marshal.dump(aes_data)
-        aes_path = File.expand_path('aes', @config_path)
-        File.open(aes_path, 'w') { |f| f.write(rsa_key.public_encrypt(dump)) }
-        @options['aes'] = aes_path
+        # Password
+        password = @ui.password_setup
 
         # Store
-        store_options = @ui.store_setup
-        if store_options['type'] == 'filesystem'
-          store_options['path'] = File.expand_path(store_options['path'], @config_path)
-        end
-        @options['store'] = store_options
+        @options['store'] = @ui.store_setup
 
         # Write out config
-        File.open(File.expand_path('config', @config_path), 'w') { |f| f.print(@options.to_yaml) }
+        File.open(File.expand_path('config.yml', @config_path), 'w') { |f| f.print(@options.to_yaml) }
+      end
+
+      # Expand relative paths, using config_path as parent
+      if @options['store']['type'] == 'filesystem' &&
+            @options['store'].has_key?('path')
+
+        @options['store']['path'] =
+          File.expand_path(@options['store']['path'], @config_path)
       end
+
       store = Store[@options['store']['type']].new(@options['store'].reject { |k, _| k == 'type' })
-      @database = Database.new(aes_data['key'], aes_data['iv'], store)
-      @ui.database = @database
+      @database = Database.new(password, store)
       main_loop
     end
 
     def main_loop
-      options = {}
+      group_tree = [@database.top_group]
       loop do
-        choice = @ui.menu(options)
+        current_group = group_tree.last
+        menu_options = {
+          :group => current_group,
+          :at_top => at_top?(current_group),
+          :dirty => @database.dirty?,
+          :enable_up => group_tree.length > 2
+        }
+        choice = @ui.menu(menu_options)
 
         case choice
         when :new
           result = @ui.get_new_entry
-          @database.add(result[:site], result[:username], result[:password], options)
-        when :delete
-          @ui.delete_entry(options)
+          next if result.nil?
+
+          new_site = Site.new(*result.values_at(:site, :username, :password))
+          if site = current_group.sites.find { |s| s == new_site }
+            if @ui.confirm_overwrite_entry(site)
+              site.password = new_site.password
+            end
+          else
+            current_group.add_site(new_site)
+          end
+        when :edit
+          result = @ui.choose_entry_to_edit(current_group)
+          next if result.nil?
+          site = result[:site]
+
+          loop do
+            which = @ui.edit_entry(site)
+            case which
+            when :change_username
+              new_username = @ui.change_username(site.username)
+              if new_username
+                site.username = new_username
+              end
+            when :change_password
+              new_password = @ui.get_new_password
+              if new_password
+                site.password = new_password
+              end
+            when :delete
+              if @ui.confirm_delete_entry(site)
+                current_group.remove_site(site)
+                break
+              end
+            when nil
+              break
+            end
+          end
         when :new_group
-          options = @ui.get_new_group
+          group_name = @ui.get_new_group
+          group = Group.new(group_name)
+          current_group.add_group(group)
+          group_tree << group
         when :save
-          @database.save
+          password = @ui.get_password
+          if !@database.save(password)
+            @ui.display_invalid_password_notice
+          end
         when :quit
           break
         when Hash
-          options = choice
+          if choice[:group]
+            group_tree << choice[:group]
+          end
         when :top
-          options = {}
+          while group_tree.length > 1
+            group_tree.pop
+          end
+        when :up
+          group_tree.pop
         end
       end
     end
+
+    private
+
+    def at_top?(group)
+      group.equal?(@database.top_group)
+    end
   end
 end