keyring 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 / 2011-05-28
+
+* 1 major enhancement
+  * Birthday!

data/README.md

@@ -0,0 +1,70 @@
+keyring
+===========
+
+A simple framework for storing passwords in certain keyring systems.
+This gem is heavily inspired by python-keyring.
+
+Examples
+--------
+
+The simplest case is to use a single global keyring instance:
+
+    require "keyring"
+    Keyring.set_password("service", "user", "password")
+    Keyring.get_password("service", "user") == "password"
+    
+This instance parses ./.rbkeyringrc and ~/.rbkeyringrc (in that order)
+for a valid configuration. The configuration determines the default
+module to use along with some parameters, e.g., the following
+configuration uses the kwallet module (available as keyring-kwallet
+gem):
+
+    ---
+    module: keyring-kwallet
+    params: 
+       folder: myfolder
+       app: myapp
+       
+Alternatively you can create instances of your favourite keyring module:
+
+   simple = Keyring::SimpleKeyring.new
+   kwallet = Keyring::KWalletKeyring.new folder: "myfolder", app: "myapp"
+   simple.set_password("service", "user", kwallet.get_password("service", "user"))
+   
+The concrete parameters depend on the backend type.
+
+Install
+-------
+
+gem install keyring
+
+Author
+------
+
+Original author: Frank Fischer
+
+License
+-------
+
+(The MIT License) FIXME (different license?)
+
+Copyright (c) 2011 FIXME (author's name)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+
+begin
+    require 'bones'
+rescue LoadError
+    abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'spec:run'
+task 'gem:release' => 'spec:run'
+
+Bones {
+    name     'keyring'
+    authors  'Frank Fischer'
+    email    'frank.fischer@mathematik.tu-chemnitz.de'
+    url      'http://darcsden.com/lyro/keyring'
+}
+

data/lib/keyring.rb

@@ -0,0 +1,15 @@
+
+module Keyring
+
+    # :stopdoc:
+    LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+    PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+    VERSION = ::File.read(PATH + 'version.txt').strip
+
+    %w(Keyring.rb SimpleKeyring.rb).each do |fname|
+        require File.join(LIBPATH, "keyring", fname)
+    end
+
+end  # module Keyring
+
+

data/lib/keyring/Keyring.rb

@@ -0,0 +1,95 @@
+require 'yaml'
+
+module Keyring
+
+    @keyring = nil
+    @backends = {}
+
+    # Registers a backend
+    def self.add_backend( name, backend )
+        @backends[name] = backend
+    end
+
+    # Changes the global default key-ring
+    def self.set_keyring( keyring )
+        raise ArgumentError, "Expected keyring" unless keyring.kind_of? Keyring
+        @keyring = keyring
+    end
+
+    # Returns the global default keyring
+    def self.keyring
+        unless @keyring
+            @backends.each_value do |backend|
+                keyring = backend.new
+                if keyring.supported?
+                    @keyring = keyring
+                    break if keyring.recommended?
+                end
+            end
+        end
+        @keyring
+    end
+
+    def self.method_missing(name, *args, &block)
+        keyring.send(name, *args, &block)
+    end
+
+    # Base class for all Keyrings.
+    # All keyring backends should inherit from this class.
+    class Keyring
+        # Determines if this keyring is supported by the current platform.
+        # @return [true, false] whether the keyring is supported by the current platform
+        def supported?
+            false
+        end
+
+        # Determines if this keyring is recommended by the current platform.
+        # @return [true, false] whether the keyring is recommended by the current platform
+        def recommended?
+            false
+        end
+
+        # Sets the user password for a certain service.
+        # @param [String] service the name of the service
+        # @param [String] username the name of the user
+        # @param [String, nil] password the new password to be stored
+        def set_password( service, username, password )
+            raise NotImplementedError, "Setting a password is not supported"
+        end
+
+        # Removes a user password for a certain service from the keyring.
+        # This is the same as setting the password to nil.
+        # @param [String] service the name of the service
+        # @param [String] username the name of the user
+        def delete_password( service, username )
+            set_password( service, username, nil )
+        end
+
+        # Returns the current user password for a certain service.
+        # @param [String] service the name of the service
+        # @param [String] username the name of the user
+        # @return [String, nil] the current password if available
+        def get_password( service, username )
+            raise NotImplementedError, "Retrieving a password is not supported"
+        end
+    end
+
+
+    # load keyring
+    [".rbkeyringrc", "#{File.join(ENV['HOME'], '.rbkeyringrc')}"].each do |fname|
+        begin
+            File.open(fname, "r") do |f|
+                puts "load #{fname}"
+                config = YAML::load(f.read)
+                if config
+                    kr_module = config["module"]
+                    require kr_module
+                    set_keyring(@backends[kr_module].new config["parameters"])
+                    break
+                end
+            end
+        rescue IOError, Errno::ENOENT
+        end
+    end
+
+end

data/lib/keyring/SimpleKeyring.rb

@@ -0,0 +1,38 @@
+module Keyring
+
+    # Simple keyring holding all keys in memory.
+    class SimpleKeyring < Keyring
+        def initialize
+            @services = {}
+        end
+
+        def supported?
+            true
+        end
+
+        def recommended?
+            false
+        end
+
+        def get_password( service, username )
+            passwords = @services[service]
+            if passwords
+                passwords[username]
+            else
+                nil
+            end
+        end
+
+        def set_password( service, username, password )
+            passwords = @services[service]
+            unless passwords
+                passwords = {}
+                @services[service] = passwords
+            end
+            passwords[username] = password
+        end
+    end
+
+    add_backend("simple", SimpleKeyring)
+
+end

data/spec/keyring_spec.rb

@@ -0,0 +1,129 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Keyring::Keyring, "after creation" do
+    before do
+        @keyring = Keyring::Keyring.new
+    end
+
+    it "should not be supported" do
+        @keyring.supported?.should == false
+    end
+
+    it "should not be recommended" do
+        @keyring.recommended?.should == false
+    end
+
+    it "should raise an error when getting a password" do
+        lambda{@keyring.get_password("service", "user")}.should raise_error
+    end
+
+    it "should raise an error when setting a password" do
+        lambda{@keyring.set_password("service", "user", "pass")}.should raise_error
+    end
+
+    it "should raise an error when deleting a password" do
+        lambda{@keyring.delete_password("service", "user", "pass")}.should raise_error
+    end
+end
+
+
+describe Keyring::SimpleKeyring, "after creation" do
+    before do
+        @keyring = Keyring::SimpleKeyring.new
+    end
+
+    it "should be supported" do
+        @keyring.supported?.should == true
+    end
+
+    it "should not be recommended" do
+        @keyring.recommended?.should == false
+    end
+
+    it "should return nil when getting a password" do
+        @keyring.get_password("service", "user").should == nil
+    end
+
+    it "should not raise an error when setting a password" do
+        lambda{@keyring.set_password("service", "user", "pass")}.should_not raise_error
+    end
+
+    it "should not raise an error when deleting a password" do
+        lambda{@keyring.delete_password("service", "user")}.should_not raise_error
+    end
+end
+
+
+describe Keyring::SimpleKeyring, "with a single password" do
+    before do
+        @keyring = Keyring::SimpleKeyring.new
+        @keyring.set_password "service", "user", "pass"
+    end
+
+    it "should contain the password" do
+        @keyring.get_password("service", "user").should == "pass"
+    end
+
+    it "should not contain a password for another user" do
+        @keyring.get_password("service", "user2").should == nil
+    end
+
+    it "should not contain a password for another service" do
+        @keyring.get_password("service2", "user").should == nil
+    end
+
+    it "should not contain a password after deletion" do
+        @keyring.delete_password("service", "user")
+        @keyring.get_password("service", "user").should == nil
+    end
+
+    it "should contain the password after deletion of another user" do
+        @keyring.delete_password("service", "user2")
+        @keyring.get_password("service", "user").should == "pass"
+    end
+
+    it "should contain the password after deletion of another service" do
+        @keyring.delete_password("service2", "user")
+        @keyring.get_password("service", "user").should == "pass"
+    end
+end
+
+
+describe Keyring::SimpleKeyring, "with a serveral passwords" do
+    before do
+        @keyring = Keyring::SimpleKeyring.new
+        @keyring.set_password "service", "user", "pass"
+        @keyring.set_password "service", "user2", "pass2"
+        @keyring.set_password "service2", "user", "pass21"
+        @keyring.set_password "service2", "user3", "pass23"
+    end
+
+    it "should contain all passwords" do
+        @keyring.get_password("service", "user").should == "pass"
+        @keyring.get_password("service", "user2").should == "pass2"
+        @keyring.get_password("service2", "user").should == "pass21"
+        @keyring.get_password("service2", "user3").should == "pass23"
+    end
+
+    it "should not contain a password for another user" do
+        @keyring.get_password("service", "user3").should == nil
+        @keyring.get_password("service2", "user2").should == nil
+    end
+
+    it "should not contain a password after deletion" do
+        @keyring.delete_password("service", "user")
+        @keyring.get_password("service", "user").should == nil
+    end
+
+    it "should contain the password after deletion of another user" do
+        @keyring.delete_password("service", "user2")
+        @keyring.get_password("service", "user").should == "pass"
+    end
+
+    it "should contain the password after deletion of another service" do
+        @keyring.delete_password("service2", "user")
+        @keyring.get_password("service", "user").should == "pass"
+    end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib keyring]))
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+

data/version.txt

@@ -0,0 +1 @@
+0.1.0

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: keyring
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Frank Fischer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-28 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.6.5
+  type: :development
+  version_requirements: *id001
+description: |-
+  A simple framework for storing passwords in certain keyring systems.
+  This gem is heavily inspired by python-keyring.
+email: frank.fischer@mathematik.tu-chemnitz.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+files: 
+- History.txt
+- README.md
+- Rakefile
+- lib/keyring.rb
+- lib/keyring/Keyring.rb
+- lib/keyring/SimpleKeyring.rb
+- spec/keyring_spec.rb
+- spec/spec_helper.rb
+- version.txt
+has_rdoc: true
+homepage: http://darcsden.com/lyro/keyring
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: keyring
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple framework for storing passwords in certain keyring systems.
+test_files: []
+