mellon 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d709112b62b9ed79d5d650602042faf2a3dfc2f
-  data.tar.gz: deda5ba7ba3a00ea77b3f914fd23c8d14cd7c04a
+  metadata.gz: def326c20e1ca30c9928c4832d30685545243fc0
+  data.tar.gz: 21b5882854d42a868ae1dd13238f230f4d2894b1
 SHA512:
-  metadata.gz: ede7a998d84a0504c55bcf1f203c832a8c800e647f43ff4c17a7edfb1801ee2e37292f5a771e04d97798985af4c2e0c32d9507dc7c5428d73acc6ed6ea38a45d
-  data.tar.gz: 19fef434f6cdd5a71599f9774a4d56e284ae82d51d819b2a001de0626da9d237ada8eaef8e89e4569d3fb91877d732169c9cefe0429eea11ae3524794bdacb70
+  metadata.gz: 148f9e5dab12df775f0635d07f7f5da20b0d6f1c9361e8b8b757aa9a130f8a813634f48a2c5b9d4bbe5b2ef330c894fedc5d4fad7edf416e3fb355f124c108bd
+  data.tar.gz: 75c894dcf7e31e103c29d0c049d9adb4820cc1984b9a2c4d5a76a3fa5588d5cebfb0df892f668cd589ed168e4d0581a997797281ee8556b9f70e110a59b03dd7

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+[HEAD][]
+--------
+
+[v1.1.0][]
+----------
+
+- `mellon list -k keychain` now lists all keys in given keychain (d34052c0)
+- `mellon list` now lists all keys in all keychains (e9d67f10)
+- Implemented Mellon::Keychain#keys (7ee9c3fe)
+- Implemented equality checking for Mellon::Keychain (4368c73c)
+
+[v1.0.0][]
+----------
+
+Initial release!
+
+[HEAD]: https://github.com/elabs/mellon/compare/v1.1.0...HEAD
+[v1.1.0]: https://github.com/elabs/mellon/compare/v1.0.0...v1.1.0
+[v1.0.0]: https://github.com/elabs/mellon/compare/24b83977d...v1.0.0

data/bin/mellon

@@ -55,12 +55,33 @@ Slop.parse(strict: true, help: true) do
     exit
   end
 
-  description "list globally known keychains."
+  description "list keychain entries."
   command "list" do
+    banner "Usage: mellon list [options]"
+    define_common[self]
+
     run do
-      puts "Available keychains:"
-      Mellon::Keychain.list.each do |keychain|
-        puts "  #{keychain.name}"
+      if $keychain.nil?
+        entries = {}
+        Mellon::Keychain.list.map do |keychain|
+          keys = keychain.keys
+          entries[keychain] = keys if keys.length > 0
+        end
+
+        if entries.empty?
+          puts "There are no keychains with entries."
+        else
+          puts entries.map { |keychain, entries|
+            joiner = "\n    "
+            "#{keychain.path}:#{joiner}" << entries.join(joiner)
+          }.join("\n\n")
+        end
+      else
+        joiner = "\n    "
+        keychain = $keychain
+        entries  = keychain.keys
+
+        puts "#{keychain.path}:#{joiner}" << entries.join(joiner)
       end
     end
   end

data/lib/mellon.rb

@@ -1,4 +1,5 @@
 require "mellon/version"
+require "mellon/utils"
 require "mellon/shell_utils"
 require "mellon/keychain"
 require "mellon/store"
@@ -6,6 +7,14 @@ require "mellon/store"
 module Mellon
   KEYCHAIN_REGEXP = /"(.+)"/
 
+  DEFAULT_OPTIONS = { type: :note }
+  TYPES = {
+    "note" => {
+      kind: "secure note",
+      type: "note"
+    }
+  }
+
   class Error < StandardError; end
   class CommandError < Error; end
 end

data/lib/mellon/keychain.rb

@@ -3,14 +3,6 @@ require "plist"
 module Mellon
   # Keychain provides simple methods for reading and storing keychain entries.
   class Keychain
-    DEFAULT_OPTIONS = { type: :note }
-    TYPES = {
-      "note" => {
-        kind: "secure note",
-        type: "note"
-      }
-    }
-
     class << self
       # Find the first keychain that contains the key.
       #
@@ -46,13 +38,13 @@ module Mellon
       # @return [Keychain] default keychain
       def default
         keychain_path = ShellUtils.security("default-keychain")[KEYCHAIN_REGEXP, 1]
-        Keychain.new(keychain_path, ensure_exists: false)
+        new(keychain_path, ensure_exists: false)
       end
 
       # @return [Array<Keychain>] all available keychains
       def list
         ShellUtils.security("list-keychains").scan(KEYCHAIN_REGEXP).map do |(keychain_path)|
-          Keychain.new(keychain_path, ensure_exists: false)
+          new(keychain_path, ensure_exists: false)
         end
       end
     end
@@ -107,6 +99,36 @@ module Mellon
       end
     end
 
+    # Retrieve all available keys.
+    #
+    # @return [Array<String>]
+    def keys
+      Utils.parse_dump(command "dump-keychain").map do |keychain, info|
+        info[:label]
+      end
+    end
+
+    # @return a hash unique to keychains of the same path
+    def hash
+      path.hash
+    end
+
+    # @param other
+    # @return [Boolean] true if the keychains have the same path
+    def eql?(other)
+      self == other or super
+    end
+
+    # @param other
+    # @return [Boolean] true if the keychains have the same path
+    def ==(other)
+      if other.is_a?(Keychain)
+        path == other.path
+      else
+        super
+      end
+    end
+
     private
 
     # Read a key from the keychain.
@@ -115,7 +137,7 @@ module Mellon
     # @return [Array<Hash, String>, nil] tuple of entry info, and text contents, or nil if key does not exist
     def read(key)
       command "find-generic-password", "-g", "-l", key do |info, password_info|
-        [parse_info(info), parse_contents(password_info)]
+        [Utils.parse_info(info), Utils.parse_contents(password_info)]
       end
     rescue CommandError => e
       nil
@@ -131,13 +153,13 @@ module Mellon
     # @param [String] key
     # @param [String] data
     # @param [Hash] options
-    # @option options [#to_s] :type (:note) one of Keychain::TYPES
+    # @option options [#to_s] :type (:note) one of Mellon::TYPES
     # @option options [String] :account_name ("")
     # @option options [String] :service_name (key)
     # @option options [String] :label (service_name)
     # @raise [CommandError] if writing fails
     def write(key, data, options = {})
-      info = build_info(key, options)
+      info = Utils.build_info(key, options)
 
       command "add-generic-password",
         "-a", info[:account_name],
@@ -156,7 +178,7 @@ module Mellon
     # @param [Hash] options
     # @option (see #write)
     def delete(key, options = {})
-      info = build_info(key, options)
+      info = Utils.build_info(key, options)
 
       command "delete-generic-password",
         "-a", info[:account_name],
@@ -173,67 +195,5 @@ module Mellon
       command += [path]
       ShellUtils.security *command, &block
     end
-
-    private
-
-    # Build an info hash used for #write and #delete.
-    #
-    # @param [String] key
-    # @param [Hash] options
-    # @return [Hash]
-    def build_info(key, options = {})
-      options = DEFAULT_OPTIONS.merge(options)
-
-      note_type = TYPES.fetch(options.fetch(:type, :note).to_s)
-      account_name = options.fetch(:account_name, "")
-      service_name = options.fetch(:service_name, key)
-      label = options.fetch(:label, service_name)
-
-      {
-        account_name: account_name,
-        service_name: service_name,
-        label: label,
-        kind: note_type.fetch(:kind),
-        type: note_type.fetch(:type),
-      }
-    end
-
-    # Parse entry information.
-    #
-    # @param [String] info
-    # @return [Hash]
-    def parse_info(info)
-      extract = lambda { |key| info[/#{key}.+=(?:<NULL>|[^"]*"(.+)")/, 1].to_s }
-      {
-        account_name: extract["acct"],
-        kind: extract["desc"],
-        type: extract["type"],
-        label: extract["0x00000007"],
-        service_name: extract["svce"],
-      }
-    end
-
-    # Parse entry contents.
-    #
-    # @param [String]
-    # @return [String]
-    def parse_contents(password_info)
-      unpacked = password_info[/password: 0x([a-f0-9]+)/i, 1]
-
-      password = if unpacked
-        [unpacked].pack("H*")
-      else
-        password_info[/password: "(.+)"/m, 1]
-      end
-
-      password ||= ""
-
-      parsed = Plist.parse_xml(password.force_encoding("".encoding))
-      if parsed and parsed["NOTE"]
-        parsed["NOTE"]
-      else
-        password
-      end
-    end
   end
 end

data/lib/mellon/utils.rb

@@ -0,0 +1,92 @@
+module Mellon
+  module Utils
+    module_function
+
+    # Build an entry info hash.
+    #
+    # @param [String] key
+    # @param [Hash] options
+    # @return [Hash]
+    def build_info(key, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+
+      note_type = TYPES.fetch(options.fetch(:type, :note).to_s)
+      account_name = options.fetch(:account_name, "")
+      service_name = options.fetch(:service_name, key)
+      label = options.fetch(:label, service_name)
+
+      {
+        account_name: account_name,
+        service_name: service_name,
+        label: label,
+        kind: note_type.fetch(:kind),
+        type: note_type.fetch(:type),
+      }
+    end
+
+    # @param [String]
+    # @return [Array<[keychain_path, info]>]
+    def parse_dump(keychain_dump)
+      attributes_start = /attributes:/
+      keychain_start = /keychain: #{KEYCHAIN_REGEXP}/
+
+      keychain_path = nil
+      state = :ignoring
+      info_chunks = keychain_dump.each_line.chunk do |line|
+        if line =~ attributes_start
+          state = :attributes
+          nil
+        elsif line =~ keychain_start
+          state = :ignoring
+          keychain_path = $1
+          nil
+        elsif state == :attributes
+          keychain_path
+        end
+      end
+
+      info_chunks.each_with_object([]) do |(keychain_path, chunk), keys|
+        info = parse_info(chunk.join)
+        keys << [keychain_path, info] if TYPES.has_key?(info[:type])
+      end
+    end
+
+    # Parse entry information.
+    #
+    # @param [String] info
+    # @return [Hash]
+    def parse_info(info)
+      extract = lambda { |key| info[/#{key}.+=(?:<NULL>|[^"]*"(.+)")/, 1].to_s }
+      {
+        account_name: extract["acct"],
+        kind: extract["desc"],
+        type: extract["type"],
+        label: extract["0x00000007"],
+        service_name: extract["svce"],
+      }
+    end
+
+    # Parse entry contents.
+    #
+    # @param [String]
+    # @return [String]
+    def parse_contents(password_string)
+      unpacked = password_string[/password: 0x([a-f0-9]+)/i, 1]
+
+      password = if unpacked
+        [unpacked].pack("H*")
+      else
+        password_string[/password: "(.+)"/m, 1]
+      end
+
+      password ||= ""
+
+      parsed = Plist.parse_xml(password.force_encoding("".encoding))
+      if parsed and parsed["NOTE"]
+        parsed["NOTE"]
+      else
+        password
+      end
+    end
+  end
+end

data/lib/mellon/version.rb

@@ -1,3 +1,3 @@
 module Mellon
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/mellon/keychain_spec.rb

@@ -11,13 +11,35 @@ describe Mellon::Keychain do
     keychain.path.should eq keychain_path
   end
 
+  specify "keychain can be stored in hash" do
+    hash = {}
+    hash[keychain] = "some value"
+    hash[Mellon::Keychain.new(keychain.path)].should eq "some value"
+  end
+
+  describe "#==" do
+    it "is equal to another keychain with same path" do
+      keychain.should eq Mellon::Keychain.new(keychain.path)
+    end
+
+    it "is not equal to any other object" do
+      keychain.should_not eq({})
+    end
+  end
+
   describe "#initialize" do
     it "raises an error if keychain does not exist" do
       expect { Mellon::Keychain.new("missing.keychain") }.to raise_error(Mellon::Error, /missing.keychain/)
     end
   end
 
-  describe "fetch" do
+  describe "#keys" do
+    it "lists all keys available in the keychain" do
+      keychain.keys.should =~ ["simple", "existing", "encoded", "plist", "empty", "doomed", "json store", "yaml store"]
+    end
+  end
+
+  describe "#fetch" do
     it "delegates (and as such, behaves equally) to #[]" do
       keychain.should_receive(:[]).with("simple").and_call_original
       keychain.fetch("simple").should eq "Simple note"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mellon
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kim Burgestrand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-09 00:00:00.000000000 Z
+date: 2014-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: plist
@@ -104,6 +104,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -114,6 +115,7 @@ files:
 - lib/mellon/keychain.rb
 - lib/mellon/shell_utils.rb
 - lib/mellon/store.rb
+- lib/mellon/utils.rb
 - lib/mellon/version.rb
 - mellon.gemspec
 - spec/keychain.keychain