mellon 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8678fd19fa9cfae39812816421a3909d45eaeb2
-  data.tar.gz: 03e80fc20be1c93f769f25fcd081e3166fe1deb4
+  metadata.gz: 76d1c2268781b0099e7c924852a17bfbe0f52fa6
+  data.tar.gz: 108c0fa6d05f1f87307fcc52e9c15738b83b9c32
 SHA512:
-  metadata.gz: a8da897237648b63ee5b3c21d9ae0dfad9f90e6c24a9a70ab714de7d352deb997201250eeb1995e17c8eae6fce8b315b2890627182631c9d1b67b2a9e6128ec4
-  data.tar.gz: f1d71b5cd507568290b8aed46feafe6390eedb4481043e1391a527a86ab5af875a41b6ea8ca5812f83a2339d726e0d11ea98368ec6909e1efac9e1f78d9456ec
+  metadata.gz: d17a055a2d6f33bb9099bdfca03cee93e0b6ee70ab133b4ae9e749a115319af8f373d72632698c1a500f87d73d701f484d8db4acf9cb9581098ef113d3ed1c59
+  data.tar.gz: b3ec39f219f671ff33ffb60a14f6f73eee5cbb10551e2f3a66c119acacd043da68dd4845c41721ccd36fcd2537c0674633cecd473ba53f6fab2b42a9c58bc42e

data/CHANGELOG.md

@@ -1,6 +1,13 @@
 [HEAD][]
 --------
 
+[v1.2.0][]
+----------
+
+- Add Mellon::Store#to_h (47523c2f)
+- Add more verbosity when $DEBUG is set (29b97367)
+- Match only keychain name in Keychain.find (44693409) [closes #5]
+
 [v1.1.1][]
 ----------
 
@@ -21,7 +28,8 @@
 
 Initial release!
 
-[HEAD]: https://github.com/elabs/mellon/compare/v1.1.1...HEAD
+[HEAD]: https://github.com/elabs/mellon/compare/v1.2.0...HEAD
+[v1.2.0]: https://github.com/elabs/mellon/compare/v1.1.1...v1.2.0
 [v1.1.1]: https://github.com/elabs/mellon/compare/v1.1.0...v1.1.1
 [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/README.md

@@ -32,7 +32,7 @@ See instructions over at [econfig-keychain](https://github.com/elabs/econfig-key
 
 # Documentation
 
-An API reference can be found at [rdoc.info/github/elabs/mellon](http://rdoc.info/github/elabs/mellon/master/frames).
+An API reference can be found at [rubydoc.info/github/elabs/mellon](http://www.rubydoc.info/github/elabs/mellon/).
 
 ## Mellon::Keychain
 
@@ -46,7 +46,7 @@ keychain["ruby note"] # => "Hello from Ruby!"
 keychain["ruby note"] = nil # deletes keychain note `ruby note`
 ```
 
-More documentation can be found at the [API reference for Mellon::Keychain](http://rdoc.info/github/elabs/mellon/master/Mellon/Keychain).
+More documentation can be found at the [API reference for Mellon::Keychain](http://www.rubydoc.info/github/elabs/mellon/Mellon/Keychain).
 
 ## Mellon::Store
 
@@ -63,7 +63,7 @@ store["some key"] # => "Hello from Ruby!"
 store.keychain[store.project_name] # => "---\nsome key: Hello from Ruby!\n"
 ```
 
-More documentation can be found at the [API reference for Mellon::Store](http://rdoc.info/github/elabs/mellon/master/Mellon/Store).
+More documentation can be found at the [API reference for Mellon::Store](http://www.rubydoc.info/github/elabs/mellon/Mellon/Store).
 
 ## Command-line interface
 
@@ -75,5 +75,5 @@ When you install the Mellon gem you also get an executable called `mellon`. See
 
 [Elabs]: http://www.elabs.se/
 [elabs logo]: ./elabs-logo.png?raw=true
-[Mellon::Keychain]: #mellon-keychain
-[Mellon::Store]: #mellon-store
+[Mellon::Keychain]: #mellonkeychain
+[Mellon::Store]: #mellonstore

data/Rakefile

@@ -3,6 +3,9 @@ require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new
 
+require "yard"
+YARD::Rake::YardocTask.new
+
 task :console do
   exec *%w[bundle exec pry -r mellon]
 end

data/lib/mellon.rb

@@ -1,6 +1,5 @@
 require "mellon/version"
 require "mellon/utils"
-require "mellon/shell_utils"
 require "mellon/keychain"
 require "mellon/store"
 

data/lib/mellon/keychain.rb

@@ -11,7 +11,7 @@ module Mellon
       # @param [String] key
       # @return [Keychain, nil]
       def search(key)
-        output = ShellUtils.security("find-generic-password", "-l", key)
+        output = Utils.security("find-generic-password", "-l", key)
         new(output[/keychain: "(.+)"/i, 1], ensure_exists: false)
       rescue CommandError => e
         raise unless e.message =~ ENTRY_MISSING
@@ -26,13 +26,14 @@ module Mellon
       def find(name)
         quoted = Regexp.quote(name)
         regexp = Regexp.new(quoted, Regexp::IGNORECASE)
+        keychains = list
 
-        keychain = list.find do |keychain|
-          keychain.path =~ regexp
+        keychain = keychains.find do |keychain|
+          keychain.name =~ regexp
         end
 
         if keychain.nil?
-          raise KeyError, "Could not find keychain “#{name}” in #{list.map(&:name).join(", ")}"
+          raise KeyError, "Could not find keychain “#{name}” in #{keychains.map(&:name).join(", ")}"
         end
 
         keychain
@@ -40,13 +41,13 @@ module Mellon
 
       # @return [Keychain] default keychain
       def default
-        keychain_path = ShellUtils.security("default-keychain")[KEYCHAIN_REGEXP, 1]
+        keychain_path = Utils.security("default-keychain")[KEYCHAIN_REGEXP, 1]
         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)|
+        Utils.security("list-keychains").scan(KEYCHAIN_REGEXP).map do |(keychain_path)|
           new(keychain_path, ensure_exists: false)
         end
       end
@@ -197,7 +198,7 @@ module Mellon
     # @param [Array<String>] command
     def command(*command, &block)
       command += [path]
-      ShellUtils.security *command, &block
+      Utils.security *command, &block
     end
   end
 end

data/lib/mellon/store.rb

@@ -59,6 +59,11 @@ module Mellon
       dump data.merge(key => value)
     end
 
+    # @return [Hash]
+    def to_h
+      data
+    end
+
     private
 
     def data

data/lib/mellon/utils.rb

@@ -1,4 +1,8 @@
+require "open3"
+require "shellwords"
+
 module Mellon
+  # @api private
   module Utils
     module_function
 
@@ -88,5 +92,46 @@ module Mellon
         password
       end
     end
+
+    # @see #sh
+    def security(*command, &block)
+      sh("security", *command, &block)
+    end
+
+    # @overload sh(*command, &block)
+    #   Yields stdout and stderr to the given block.
+    #
+    # @overload sh(*command)
+    #   Returns stdout.
+    #
+    # @raise [CommandError] if command exited with a non-zero exit status.
+    def sh(*command)
+      $stderr.puts "$ " + command.join(" ") if $VERBOSE
+      stdout, stderr, status = Open3.capture3(*command)
+
+      stdout.chomp!
+      stderr.chomp!
+
+      if $DEBUG
+        $stderr.puts stdout.gsub(/(?<=\n|\A)/, "--> ") unless stdout.empty?
+        $stderr.puts stderr.gsub(/(?<=\n|\A)/, "--! ") unless stderr.empty?
+      end
+
+      unless status.success?
+        error_string = Shellwords.join(command)
+        error_string << "\n"
+
+        stderr = "<no output>" if stderr.empty?
+        error_string << "  " << stderr.chomp
+
+        raise CommandError, "[ERROR] #{error_string}"
+      end
+
+      if block_given?
+        yield [stdout, stderr]
+      else
+        stdout
+      end
+    end
   end
 end

data/lib/mellon/version.rb

@@ -1,3 +1,3 @@
 module Mellon
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/mellon.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "yard"
 end

data/spec/mellon/keychain_spec.rb

@@ -3,27 +3,108 @@ describe Mellon::Keychain do
     Mellon::Keychain.new(keychain_path)
   end
 
+  describe ".search" do
+    it "returns the first keychain that contains the requested entry" do
+      stub_command "security find-generic-password -l booboom", stdout: <<-STDOUT
+keychain: "/Users/dev/Library/Keychains/projects.keychain"
+class: "genp"
+attributes:
+    0x00000007 <blob>="booboom"
+    0x00000008 <blob>=<NULL>
+    "acct"<blob>=<NULL>
+    "cdat"<timedate>=0x32303135303132333037343035395A00  "20150123074059Z\000"
+    "crtr"<uint32>=<NULL>
+    "cusi"<sint32>=<NULL>
+    "desc"<blob>="secure note"
+    "gena"<blob>=<NULL>
+    "icmt"<blob>=<NULL>
+    "invi"<sint32>=<NULL>
+    "mdat"<timedate>=0x32303135303132333037343035395A00  "20150123074059Z\000"
+    "nega"<sint32>=<NULL>
+    "prot"<blob>=<NULL>
+    "scrp"<sint32>=<NULL>
+    "svce"<blob>="booboom"
+    "type"<uint32>="note"
+      STDOUT
+
+      keychain = Mellon::Keychain.search "booboom"
+      expect(keychain.path).to eq "/Users/dev/Library/Keychains/projects.keychain"
+      expect(keychain.name).to eq "projects"
+    end
+
+    it "returns nil if the entry is missing" do
+      stub_command "security find-generic-password -l booboom", error: true, stderr: <<-STDERR
+security: SecKeychainSearchCopyNext: The specified item could not be found in the keychain.
+      STDERR
+
+      keychain = Mellon::Keychain.search "booboom"
+      expect(keychain).to eq nil
+    end
+  end
+
+  describe ".find" do
+    before do
+      stub_command "security list-keychains", stdout: <<-STDOUT
+    "/Users/dev/Library/Keychains/login.keychain"
+    "/Users/dev/Library/Keychains/projects.keychain"
+    "/Users/dev/Library/Keychains/developer.keychain"
+    "/Library/Keychains/System.keychain"
+      STDOUT
+    end
+
+    it "finds a keychain matching the given name" do
+      keychain = Mellon::Keychain.find("dev")
+      expect(keychain.name).to eq "developer"
+      expect(keychain.path).to eq "/Users/dev/Library/Keychains/developer.keychain"
+    end
+
+    it "raises an error if no keychain was found" do
+      expect { Mellon::Keychain.find("bar") }.to raise_error(KeyError, /Could not find keychain/)
+    end
+  end
+
+  specify ".list" do
+    stub_command "security list-keychains", stdout: <<-STDOUT
+  "/Users/dev/Library/Keychains/login.keychain"
+  "/Users/dev/Library/Keychains/projects.keychain"
+  "/Users/dev/Library/Keychains/developer.keychain"
+  "/Library/Keychains/System.keychain"
+    STDOUT
+
+    expect(Mellon::Keychain.list.map(&:name)).to contain_exactly("login", "projects", "developer", "System")
+  end
+
+  specify ".default" do
+    stub_command "security default-keychain", stdout: <<-STDOUT
+      "/Users/dev/Library/Keychains/login.keychain"
+    STDOUT
+
+    default = Mellon::Keychain.default
+    expect(default.path).to eq "/Users/dev/Library/Keychains/login.keychain"
+    expect(default.name).to eq "login"
+  end
+
   specify "#name" do
-    keychain.name.should eq "temporary_keychain"
+    expect(keychain.name).to eq "temporary_keychain"
   end
 
   specify "#path" do
-    keychain.path.should eq keychain_path
+    expect(keychain.path).to 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"
+    expect(hash[Mellon::Keychain.new(keychain.path)]).to eq "some value"
   end
 
   describe "#==" do
     it "is equal to another keychain with same path" do
-      keychain.should eq Mellon::Keychain.new(keychain.path)
+      expect(keychain).to eq Mellon::Keychain.new(keychain.path)
     end
 
     it "is not equal to any other object" do
-      keychain.should_not eq({})
+      expect(keychain).to_not eq({})
     end
   end
 
@@ -35,31 +116,31 @@ describe Mellon::Keychain 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"]
+      expect(keychain.keys).to contain_exactly("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"
+      expect(keychain).to receive(:[]).with("simple").and_call_original
+      expect(keychain.fetch("simple")).to eq "Simple note"
     end
 
     describe "behaves like Hash#fetch" do
       specify "when key exists" do
-        keychain.fetch("simple", nil).should eq "Simple note"
-        keychain.fetch("simple", "default value").should eq "Simple note"
-        keychain.fetch("simple", "default value") { "block value" }.should eq "Simple note"
-        keychain.fetch("simple") { "block value" }.should eq "Simple note"
+        expect(keychain.fetch("simple", nil)).to eq "Simple note"
+        expect(keychain.fetch("simple", "default value")).to eq "Simple note"
+        expect(keychain.fetch("simple", "default value") { "block value" }).to eq "Simple note"
+        expect(keychain.fetch("simple") { "block value" }).to eq "Simple note"
 
-        keychain.fetch("simple").should eq "Simple note"
+        expect(keychain.fetch("simple")).to eq "Simple note"
       end
 
       specify "when key does not exist" do
-        keychain.fetch("missing", nil).should eq nil
-        keychain.fetch("missing", "default value").should eq "default value"
-        keychain.fetch("missing", "default value") { "block value" }.should eq "block value"
-        keychain.fetch("missing") { "block value" }.should eq "block value"
+        expect(keychain.fetch("missing", nil)).to eq nil
+        expect(keychain.fetch("missing", "default value")).to eq "default value"
+        expect(keychain.fetch("missing", "default value") { "block value" }).to eq "block value"
+        expect(keychain.fetch("missing") { "block value" }).to eq "block value"
 
         expect { keychain.fetch("missing") }.to raise_error(KeyError)
       end
@@ -68,52 +149,43 @@ describe Mellon::Keychain do
 
   describe "#[key]" do
     it "reads simple entries" do
-      keychain["simple"].should eq "Simple note"
+      expect(keychain["simple"]).to eq "Simple note"
     end
 
     it "reads encoded entries" do
-      keychain["encoded"].should eq "Encoded\nnote"
+      expect(keychain["encoded"]).to eq "Encoded\nnote"
     end
 
     it "reads plist entries" do
-      keychain["plist"].should eq "Plist note."
+      expect(keychain["plist"]).to eq "Plist note."
     end
 
     it "reads empty entries" do
-      keychain["empty"].should eq ""
+      expect(keychain["empty"]).to eq ""
     end
 
     it "returns nil when there is no entry with the given name" do
-      keychain["nonexisting note"].should be_nil
-    end
-
-    it "raises an error when command exits for a reason other than key missing" do
-      error = Mellon::CommandError.new(<<-ERROR)
-security find-generic-password -g -l unreadable /Users/dev/Projects/mellon/spec/temporary_keychain.keychain
-  security: SecKeychainItemCopyAccess: In dark wake, no UI possible
-ERROR
-      Mellon::ShellUtils.should_receive(:sh).and_raise(error)
-      expect { keychain["simple"] }.to raise_error(Mellon::CommandError, /dark wake/)
+      expect(keychain["nonexisting note"]).to be_nil
     end
   end
 
   describe "#[]=" do
     it "can create a new note" do
-      keychain["new note"].should be_nil
+      expect(keychain["new note"]).to be_nil
       keychain["new note"] = "This is new data"
-      keychain["new note"].should eq "This is new data"
+      expect(keychain["new note"]).to eq "This is new data"
     end
 
     it "can write data to an existing note" do
-      keychain["existing"].should eq "Existing note."
+      expect(keychain["existing"]).to eq "Existing note."
       keychain["existing"] = "This is new"
-      keychain["existing"].should eq "This is new"
+      expect(keychain["existing"]).to eq "This is new"
     end
 
     it "can delete an existing note" do
-      keychain["doomed"].should_not be_nil
+      expect(keychain["doomed"]).to_not be_nil
       keychain["doomed"] = nil
-      keychain["doomed"].should be_nil
+      expect(keychain["doomed"]).to be_nil
     end
   end
 end

data/spec/mellon/store_spec.rb

@@ -9,75 +9,85 @@ describe Mellon::Store do
     end
 
     it "finds and uses the keychain containing the project name by default" do
-      Mellon::Keychain.should_receive(:search).with(project_name).and_return(keychain)
-      Mellon::Store.new(project_name).keychain.should eq keychain
+      expect(Mellon::Keychain).to receive(:search).with(project_name).and_return(keychain)
+      expect(Mellon::Store.new(project_name).keychain).to eq keychain
     end
 
     it "uses the default keychain is no keychain contains the project name" do
       keychain = double
-      Mellon::Keychain.should_receive(:search).with(project_name).and_return(nil)
-      Mellon::Keychain.should_receive(:default).and_return(keychain)
-      Mellon::Store.new(project_name).keychain.should eq keychain
+      expect(Mellon::Keychain).to receive(:search).with(project_name).and_return(nil)
+      expect(Mellon::Keychain).to receive(:default).and_return(keychain)
+      expect(Mellon::Store.new(project_name).keychain).to eq keychain
     end
 
     it "accepts specifying the keychain by name" do
       keychain = double
-      Mellon::Keychain.should_receive(:find).with("projects").and_return(keychain)
+      expect(Mellon::Keychain).to receive(:find).with("projects").and_return(keychain)
       store = Mellon::Store.new(project_name, keychain: "projects")
-      store.keychain.should eq keychain
+      expect(store.keychain).to eq keychain
     end
 
     it "accepts specifying the keychain object" do
       store = Mellon::Store.new(project_name, keychain: keychain)
-      store.keychain.should eq keychain
+      expect(store.keychain).to eq keychain
     end
 
     it "allows setting the serializer" do
       require "json"
       store = Mellon::Store.new("json store", keychain: keychain, serializer: JSON)
-      store["some value"].should eq "This is some json value"
+      expect(store["some value"]).to eq "This is some json value"
       store["some value"] = "New value"
-      store["some value"].should eq "New value"
+      expect(store["some value"]).to eq "New value"
     end
   end
 
   describe "#[]" do
     it "returns the value for key inside the store" do
-      store["some value"].should eq "This is some yaml value"
+      expect(store["some value"]).to eq "This is some yaml value"
     end
 
     it "returns nil if store entry does not exist" do
       store = Mellon::Store.new("missing project", keychain: keychain)
-      store["some value"].should be_nil
+      expect(store["some value"]).to be_nil
     end
 
     it "returns nil if keychain item is empty" do
       store = Mellon::Store.new("empty", keychain: keychain)
-      store["some value"].should be_nil
+      expect(store["some value"]).to be_nil
       store["some value"] = "New value"
-      store["some value"].should eq "New value"
+      expect(store["some value"]).to eq "New value"
     end
   end
 
   describe "#[]=" do
     it "assigns an existing value for key inside the store" do
-      store["some value"].should eq "This is some yaml value"
+      expect(store["some value"]).to eq "This is some yaml value"
       store["some value"] = "This is a new value"
-      store["some value"].should eq "This is a new value"
+      expect(store["some value"]).to eq "This is a new value"
     end
 
     it "creates the store entry if it does not exist" do
       store = Mellon::Store.new("missing project", keychain: keychain)
-      store["some value"].should be_nil
+      expect(store["some value"]).to be_nil
       store["some value"] = "That value"
-      store["some value"].should eq "That value"
+      expect(store["some value"]).to eq "That value"
+    end
+  end
+
+  describe "#to_h" do
+    it "returns a hash with all keys contained" do
+      store["new value"] = "This is new value"
+      expect(store.to_h).to eq({
+        "some value" => "This is some yaml value",
+        "new value"  => "This is new value"
+      })
     end
   end
 
   specify "#fetch" do
-    store.fetch("some value").should eq "This is some yaml value"
-    store.fetch("missing value", "default").should eq "default"
-    store.fetch("missing value") { "default" }.should eq "default"
+    expect(store.fetch("some value")).to eq "This is some yaml value"
+    expect(store.fetch("missing value", "default")).to eq "default"
+    expect(store.fetch("missing value") { "default" }).to eq "default"
 
     expect { store.fetch("missing value") }.to raise_error(KeyError)
   end

data/spec/mellon_spec.rb

@@ -1,5 +1,5 @@
 describe Mellon do
   specify "VERSION" do
-    defined?(Mellon::VERSION).should_not be_nil
+    expect(defined?(Mellon::VERSION)).to_not be_nil
   end
 end

data/spec/spec_helper.rb

@@ -6,14 +6,6 @@ keychain_path = File.expand_path("./temporary_keychain.keychain", __dir__)
 original_keychain_path = File.expand_path("./keychain.keychain", __dir__)
 
 RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = [:expect, :should]
-  end
-
-  config.mock_with :rspec do |c|
-    c.syntax = :should
-  end
-
   config.around do |example|
     FileUtils.cp(original_keychain_path, keychain_path)
     example.run
@@ -23,4 +15,16 @@ RSpec.configure do |config|
   define_method :keychain_path do
     keychain_path
   end
+
+  config.include(Module.new do
+    def stub_command(command, stdout: "", stderr: "", error: false)
+      status = if error
+        double("success?" => false)
+      else
+        double("success?" => true)
+      end
+
+      expect(Open3).to receive(:capture3).with(*command.split(" ")).and_return([stdout, stderr, status])
+    end
+  end)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mellon
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Kim Burgestrand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2015-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: plist
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - kim@burgestrand.se
@@ -113,7 +127,6 @@ files:
 - elabs-logo.png
 - lib/mellon.rb
 - lib/mellon/keychain.rb
-- lib/mellon/shell_utils.rb
 - lib/mellon/store.rb
 - lib/mellon/utils.rb
 - lib/mellon/version.rb
@@ -143,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A command-line utility for managing secret application credentials via OSX
@@ -154,3 +167,4 @@ test_files:
 - spec/mellon/store_spec.rb
 - spec/mellon_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/lib/mellon/shell_utils.rb

@@ -1,36 +0,0 @@
-require "open3"
-require "shellwords"
-
-module Mellon
-  module ShellUtils
-    module_function
-
-    def security(*command, &block)
-      sh("security", *command, &block)
-    end
-
-    def sh(*command)
-      $stderr.puts command.join(" ") if $VERBOSE
-      stdout, stderr, status = Open3.capture3(*command)
-
-      stdout.chomp!
-      stderr.chomp!
-
-      unless status.success?
-        error_string = Shellwords.join(command)
-        error_string << "\n"
-
-        stderr = "<no output>" if stderr.empty?
-        error_string << "  " << stderr.chomp
-
-        raise CommandError, "[ERROR] #{error_string}"
-      end
-
-      if block_given?
-        yield [stdout, stderr]
-      else
-        stdout
-      end
-    end
-  end
-end