keyring-kwallet 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,69 @@
+keyring-kwallet
+===========
+
+KWallet backend for keyring gem.
+
+Features
+--------
+
+* Provides kwallet interface for the keyring framework
+
+Examples
+--------
+
+You can use a KWallet keyring directly using an instance of Keyring::KWalletKeyring.
+
+    require "keyring-kwallet"
+    kr = Keyring::KWalletKeyring.new folder:"myfolder", app:"myapp"
+    raise "Not supported" unless kr.supported?
+    kr.get_password("service", "user")
+    
+or by putting the following in your user configuration file ~/.rbkeyringrc or the
+path-local configuration ./.rbkeyringrc
+    ---
+    module: keyring-kwallet
+    params: 
+       folder: myfolder
+       app: myapp
+
+Requirements
+------------
+
+* keyring
+* ruby-dbus >= 0.6
+
+Install
+-------
+
+* gem install keyring-kwallet
+
+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,19 @@
+
+begin
+    require 'bones'
+rescue LoadError
+    abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'spec:run'
+task 'gem:release' => 'spec:run'
+
+Bones {
+    name     'keyring-kwallet'
+    authors  'Frank Fischer'
+    email    'frank.fischer@mathematik.tu-chemnitz.de'
+    url      'http://darcsden.com/lyro/keyring-kwallet'
+    depend_on 'keyring'
+    depend_on 'ruby-dbus', '>= 0.6'
+}
+

data/lib/keyring-kwallet.rb

@@ -0,0 +1,60 @@
+
+module KeyringKwallet
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  VERSION = ::File.read(PATH + 'version.txt').strip
+  # :startdoc:
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module KeyringKwallet
+
+KeyringKwallet.require_all_libs_relative_to(__FILE__)
+

data/lib/keyring-kwallet/KWalletKeyring.rb

@@ -0,0 +1,104 @@
+require "dbus"
+require "set"
+
+module Keyring
+
+    # A keyring implementation using KDE's wallet.
+    class KWalletKeyring < Keyring
+        # A set of opened wallets, will be closed when the application exits.
+        @@open_wallets = Set.new
+
+        # Called when the application stops to close all wallets.
+        at_exit {
+            bus = DBus::SessionBus.instance
+            kw_service = bus.service("org.kde.kwalletd")
+            kwallet = kw_service.object("/modules/kwalletd")
+            kwallet.default_iface = "org.kde.KWallet"
+            kwallet.introspect
+            @@open_wallets.each do |wallet, app|
+                kwallet.disconnectApplication(wallet, app)
+            end
+        }
+
+        def initialize(params = {})
+            super()
+            params ||= {}
+            @folder = params[:folder] || params["folder"] || $0
+            @app_name = params[:app] || params["app"] || $0
+            @net_handle = nil
+
+            begin
+                bus = DBus::SessionBus.instance
+                kw_service = bus.service("org.kde.kwalletd")
+                @kwallet = kw_service.object("/modules/kwalletd")
+                @kwallet.default_iface = "org.kde.KWallet"
+                @kwallet.introspect
+            rescue => e
+                STDERR.puts "Warning: #{e}"
+                @kwallet = nil
+            end
+        end
+
+        def supported?
+            @kwallet != nil
+        end
+
+        def recommended?
+            supported?
+        end
+
+        def get_password(service, user)
+            open_wallet
+            entry = "#{user}@#{service}"
+            if @kwallet.hasEntry(@net_handle, @folder, entry, @app_name)[0]
+                @kwallet.readPassword(@net_handle, @folder, entry, @app_name)[0]
+            else
+                nil
+            end
+        end
+
+        def set_password(service, user, password)
+            open_wallet
+            if password
+                @kwallet.writePassword(@net_handle, @folder, "#{user}@#{service}", password, @app_name)
+            else
+                @kwallet.removeEntry(@net_handle, @folder, "#{user}@#{service}", @app_name)
+            end
+        end
+
+        # Deletes the folder associated with this wallet.
+        def delete_folder
+            open_wallet
+            @kwallet.removeFolder(@net_handle, @folder, @app_name)
+        end
+
+        private
+        def open_wallet
+            return if @net_handle
+            begin
+                @net_wallet, _ = @kwallet.networkWallet
+                @net_handle, _ = @kwallet.open(@net_wallet, 0, @app_name)
+
+                @@open_wallets.add [@net_wallet, @app_name]
+
+                unless @kwallet.hasFolder(@net_handle, @folder, @app_name)
+                    unless @kwallet.createFolder(@net_handle, @folder, @app_name)
+                        raise "Can't open kwallet folder #{@folder}"
+                    end
+                end
+            rescue
+                @net_handle = nil
+                raise
+            end
+        end
+
+        def self.finalizer(kwallet, wallet_name, app_name)
+            Proc.new do |*args|
+                kwallet.disconnectApplication wallet_name, app_name
+            end
+        end
+    end
+
+    add_backend( "keyring-kwallet", KWalletKeyring )
+
+end

data/spec/keyring-kwallet_spec.rb

@@ -0,0 +1,122 @@
+require "keyring"
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+PARAMS = {
+    :folder =>  "rspec-test-keyring-kwallet",
+    :app => "rspec-test-keyring-kwallet"
+}
+
+describe Keyring::KWalletKeyring, "after creation" do
+    before do
+        @keyring = Keyring::KWalletKeyring.new PARAMS
+    end
+
+    after do
+        @keyring.delete_folder
+    end
+
+    it "should be supported" do
+        @keyring.supported?.should == true
+    end
+
+    it "should be recommended" do
+        @keyring.recommended?.should == true
+    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::KWalletKeyring, "with a single password" do
+    before do
+        @keyring = Keyring::KWalletKeyring.new PARAMS
+        @keyring.set_password "service", "user", "pass"
+    end
+
+    after do
+        @keyring.delete_folder
+    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::KWalletKeyring, "with a serveral passwords" do
+    before do
+        @keyring = Keyring::KWalletKeyring.new PARAMS
+        @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
+
+    after do
+        @keyring.delete_folder
+    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-kwallet]))
+
+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,97 @@
+--- !ruby/object:Gem::Specification 
+name: keyring-kwallet
+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: keyring
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-dbus
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.6.5
+  type: :development
+  version_requirements: *id003
+description: KWallet backend for keyring gem.
+email: frank.fischer@mathematik.tu-chemnitz.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+files: 
+- History.txt
+- README.md
+- Rakefile
+- lib/keyring-kwallet.rb
+- lib/keyring-kwallet/KWalletKeyring.rb
+- spec/keyring-kwallet_spec.rb
+- spec/spec_helper.rb
+- test/test_keyring-kwallet.rb
+- version.txt
+has_rdoc: true
+homepage: http://darcsden.com/lyro/keyring-kwallet
+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-kwallet
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: KWallet backend for keyring gem.
+test_files: 
+- test/test_keyring-kwallet.rb