openid_couch_rest_model_store 1.0.0

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2-p290@openid_couch_rest_model_store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gem 'rails', '3.1.0'
+gem 'ruby-openid'
+gem 'openlogic-couchrest_model', '~> 1.0'

data/Gemfile.lock

@@ -0,0 +1,103 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.1.0)
+      actionpack (= 3.1.0)
+      mail (~> 2.3.0)
+    actionpack (3.1.0)
+      activemodel (= 3.1.0)
+      activesupport (= 3.1.0)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      i18n (~> 0.6)
+      rack (~> 1.3.2)
+      rack-cache (~> 1.0.3)
+      rack-mount (~> 0.8.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.0.0)
+    activemodel (3.1.0)
+      activesupport (= 3.1.0)
+      bcrypt-ruby (~> 3.0.0)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.0)
+      activemodel (= 3.1.0)
+      activesupport (= 3.1.0)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activeresource (3.1.0)
+      activemodel (= 3.1.0)
+      activesupport (= 3.1.0)
+    activesupport (3.1.0)
+      multi_json (~> 1.0)
+    arel (2.2.3)
+    bcrypt-ruby (3.0.1)
+    builder (3.0.0)
+    couchrest (1.1.2)
+      mime-types (~> 1.15)
+      multi_json (~> 1.0.0)
+      rest-client (~> 1.6.1)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    json (1.6.5)
+    mail (2.3.3)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.17.2)
+    multi_json (1.0.4)
+    openlogic-couchrest_model (1.0.0)
+      activemodel (~> 3.0)
+      couchrest (~> 1.1.2)
+      mime-types (~> 1.15)
+      tzinfo (~> 0.3.22)
+    polyglot (0.3.3)
+    rack (1.3.6)
+    rack-cache (1.0.3)
+      rack (>= 0.4)
+    rack-mount (0.8.3)
+      rack (>= 1.0.0)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.1.0)
+      actionmailer (= 3.1.0)
+      actionpack (= 3.1.0)
+      activerecord (= 3.1.0)
+      activeresource (= 3.1.0)
+      activesupport (= 3.1.0)
+      bundler (~> 1.0)
+      railties (= 3.1.0)
+    railties (3.1.0)
+      actionpack (= 3.1.0)
+      activesupport (= 3.1.0)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    ruby-openid (2.1.8)
+    sprockets (2.0.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.32)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  openlogic-couchrest_model (~> 1.0)
+  rails (= 3.1.0)
+  ruby-openid

data/README.rdoc

@@ -0,0 +1,63 @@
+= openid_active_record_store
+
+http://rubygems.org/gems/openid_active_record_store
+{Project}[http://rubygems.org/gems/openid_active_record_store]
+{Wiki}[http://wiki.github.com/raggi/openid_active_record_store/]
+{Source Code}[http://github.com/raggi/openid_active_record_store/]
+{Issues}[http://github.com/raggi/openid_active_record_store/issues]
+
+== DESCRIPTION:
+
+A rails engine for OpenID/Omniauth that writes to ActiveRecord for the OpenID data. Forked from an old project by Kazuyoshi Tlacaelel.
+
+== FEATURES/PROBLEMS:
+
+* Simple
+* Lowish test coverage
+* Binary column may not work well with some adapters
+
+== SYNOPSIS:
+
+    rake openid_active_record_store:install:migrations
+    rake db:migrate
+
+    # Omniauth example:
+    Rails.application.config.middleware.use(
+      OmniAuth::Strategies::GoogleApps,
+      OpenID::Store::ActiveRecord.new,
+      { :name => 'example', :domain => 'example.org' }
+    )
+
+== REQUIREMENTS:
+
+* Rails 3+
+* OpenID
+
+== INSTALL:
+
+* gem install openid_active_record_store
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Kazuyoshi Tlacaelel, James Tucker, Wildfire Interactive Inc
+
+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 NON-INFRINGEMENT.
+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,29 @@
+
+require 'rake/testtask'
+#require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.ruby_opts << '-rubygems'
+  t.libs += %w[test]
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = true
+end
+
+# desc 'Generate documentation for the plugin.'
+# RDoc::Task.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'OpenidCouchRestModelStore'
+#   rdoc.options << '--line-numbers' << '--inline-source'
+#   rdoc.rdoc_files.include('README')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+desc "build gem"
+task :gem do
+  sh "gem build openid_couch_rest_model_store.gemspec"
+end

data/app/models/openid_association.rb

@@ -0,0 +1,17 @@
+class OpenidAssociation < CouchRest::Model::Base
+  property    :issued_at, Time
+  property    :lifetime, Integer
+  property    :assoc_type, String
+  property    :handle, String
+  property    :secret, TrueClass
+  property    :target, String
+  property    :server_url, String
+  timestamps!
+
+  design do
+    view :by_target
+  end
+
+  save_design_doc!
+
+end

data/app/models/openid_nonce.rb

@@ -0,0 +1,18 @@
+class OpenidNonce < CouchRest::Model::Base
+  property  :timestamp, Integer
+  property  :salt, String
+  property  :target, String
+  property  :server_url, String
+  timestamps!
+
+  design do 
+    view :by_target
+  end
+
+  save_design_doc!
+
+  def self.exists_by_target?(timestamp, salt, target)
+    by_target(key: target).any?{|nonce| nonce.timestamp == timestamp}
+  end
+
+end

data/lib/openid/store/couch_rest_model.rb

@@ -0,0 +1,120 @@
+require 'openid/util'
+require 'openid/store/interface'
+require 'openid/association'
+require 'openssl'
+
+module OpenID
+  module Store
+    class CouchRestModel < Interface
+
+      # Put a Association object into storage.
+      # When implementing a store, don't assume that there are any limitations
+      # on the character set of the server_url.  In particular, expect to see
+      # unescaped non-url-safe characters in the server_url field.
+      def store_association(server_url, association)
+        OpenidAssociation.create!(
+          :server_url => server_url,
+          :target     => targetize(server_url),
+          :handle     => association.handle,
+          :secret     => association.secret,
+          :issued_at  => association.issued,
+          :lifetime   => association.lifetime,
+          :assoc_type => association.assoc_type
+        )
+        true
+      end
+
+      # Returns a Association object from storage that matches
+      # the server_url.  Returns nil if no such association is found or if
+      # the one matching association is expired. (Is allowed to GC expired
+      # associations when found.)
+      def get_association(server_url, handle=nil)
+        oas = OpenidAssociation.by_target(key: targetize(server_url))
+        return nil if oas.empty?
+        unless handle.nil?
+          return nil unless oas.collect(&:handle).include? handle
+          return build_association(oas.find { |oa| oa.handle == handle })
+        end
+        oas.sort_by(&:issued_at).collect { |oa| build_association(oa) }.last
+      end
+
+      # If there is a matching association, remove it from the store and
+      # return true, otherwise return false.
+      def remove_association(server_url, handle)
+        oas = OpenidAssociation.by_target(key: targetize(server_url)).all
+        return false unless oas.collect(&:handle).include? handle
+        oas.select { |oa| oa.handle == handle }.each(&:destroy).any?{|tf| tf }
+      end
+
+      # Return true if the nonce has not been used before, and store it
+      # for a while to make sure someone doesn't try to use the same value
+      # again.  Return false if the nonce has already been used or if the
+      # timestamp is not current.
+      # You can use OpenID::Store::Nonce::SKEW for your timestamp window.
+      # server_url: URL of the server from which the nonce originated
+      # timestamp: time the nonce was created in seconds since unix epoch
+      # salt: A random string that makes two nonces issued by a server in
+      #       the same second unique
+      def use_nonce(server_url, timestamp, salt)
+        return false if (timestamp - Time.now.to_i).abs > Nonce.skew
+        params = [timestamp, salt, targetize(server_url)]
+        return false if OpenidNonce.exists_by_target?(*params)
+        return create_nonce(server_url, timestamp, salt)
+      end
+
+      # Remove expired nonces and associations from the store
+      # Not called during normal library operation, this method is for store
+      # admins to keep their storage from filling up with expired data
+      def cleanup
+        cleanup_nonces
+        cleanup_associations
+      end
+
+      # Remove expired associations from the store
+      # Not called during normal library operation, this method is for store
+      # admins to keep their storage from filling up with expired data
+      def cleanup_associations
+        oas = OpenidAssociation.all.all.collect do |oa|
+          oa if build_association(oa).expires_in == 0
+        end
+        oas.compact.map(&:destroy)
+      end
+
+      # Remove expired nonces from the store
+      # Discards any nonce that is old enough that it wouldn't pass use_nonce
+      # Not called during normal library operation, this method is for store
+      # admins to keep their storage from filling up with expired data
+      def cleanup_nonces
+        now = Time.now.to_i
+        nonces = OpenidNonce.all.all.collect { |n| n if (n.timestamp - now).abs > Nonce.skew }.compact
+        nonces.map(&:destroy)
+      end
+
+      private
+
+      def targetize(server_url)
+        OpenSSL::Digest::MD5.hexdigest(server_url)
+      end
+
+      def build_association(open_id_association)
+        OpenID::Association.new(
+          open_id_association.handle,
+          open_id_association.secret,
+          open_id_association.issued_at,
+          open_id_association.lifetime,
+          open_id_association.assoc_type
+        )
+      end
+
+      def create_nonce(server_url, timestamp, salt)
+        OpenidNonce.create!(
+          :target     => targetize(server_url),
+          :server_url => server_url,
+          :timestamp  => timestamp
+        )
+        true
+      end
+
+    end
+  end
+end

data/lib/openid_couch_rest_model_store.rb

@@ -0,0 +1,10 @@
+require 'rails/engine'
+
+module OpenidCouchRestModelStore
+  class Engine < Rails::Engine
+    config.eager_load_paths << File.expand_path("../../app/models", __FILE__)
+  end
+  class Railtie < Rails::Railtie
+    # nothin'
+  end
+end

data/test/openid_store_couch_rest_model_test.rb

@@ -0,0 +1,236 @@
+require 'test_helper'
+
+class OpenidStoreCouchRestModelTest < ActiveSupport::TestCase
+
+  # ============================================================================
+  # TESTING SCENARIO
+  # ============================================================================
+
+  setup :prepare_scenario, :clean_tables
+  teardown :destroy_scenario
+
+  def prepare_scenario
+    @store = OpenID::Store::CouchRestModel.new
+    @@allowed_nonce = '0123456789abcdefghijklmnopqrst' +
+      'uvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    @@allowed_handle = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQ' +
+      'RSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
+  end
+
+  def clean_tables
+    # super duper make sure talbes are empty
+    OpenidAssociation.all.each { |ao| ao.destroy }
+    OpenidNonce.all.each { |nonce| nonce.destroy }
+  end
+
+  def destroy_scenario
+    @@allowed_handle = @@allowed_nonce = @store = nil
+  end
+
+  # ============================================================================
+  # TESTS BELOW BROUGHT FROM THE ORIGINAL 'ruby-openid' (store) test suite
+  # these methods test the association interactivity with a store object
+  # ============================================================================
+
+  def _gen_secret(n, chars=nil)
+    OpenID::CryptUtil.random_string(n, chars)
+  end
+
+  def _gen_handle(n)
+    OpenID::CryptUtil.random_string(n, @@allowed_handle)
+  end
+
+  def _gen_assoc(issued_at, lifetime=600)
+    secret = _gen_secret(20, @@allowed_handle)
+    handle = _gen_handle(128)
+    OpenID::Association.new(handle, secret, Time.now + issued_at, lifetime,
+                            'HMAC-SHA1')
+  end
+
+  def _check_retrieve(url, handle=nil, expected=nil)
+    ret_assoc = @store.get_association(url, handle)
+
+    if expected.nil?
+      assert_nil(ret_assoc)
+    else
+      %w[assoc_type handle issued lifetime secret].each do |prop|
+        ex, actual = expected.send(prop), ret_assoc.send(prop)
+        if ex.kind_of?(Time)
+          ex, actual = ex.to_i, actual.to_i
+        end
+        assert_equal ex, actual, "#{prop} doesn't match"
+      end
+    end
+  end
+
+  def _check_remove(url, handle, expected)
+    present = @store.remove_association(url, handle)
+    assert_equal(expected, present)
+  end
+
+  def test_store
+    server_url = "http://www.myopenid.com/openid"
+    assoc = _gen_assoc(issued_at=0)
+
+    # Make sure that a missing association returns no result
+    _check_retrieve(server_url)
+
+    # Check that after storage, getting returns the same result
+    @store.store_association(server_url, assoc)
+    _check_retrieve(server_url, nil, assoc)
+
+    # more than once
+    _check_retrieve(server_url, nil, assoc)
+
+    # Storing more than once has no ill effect
+    @store.store_association(server_url, assoc)
+    _check_retrieve(server_url, nil, assoc)
+
+    # Removing an association that does not exist returns not present
+    _check_remove(server_url, assoc.handle + 'x', false)
+
+    # Removing an association that does not exist returns not present
+    _check_remove(server_url + 'x', assoc.handle, false)
+
+    # Removing an association that is present returns present
+    _check_remove(server_url, assoc.handle, true)
+
+    # but not present on subsequent calls
+    _check_remove(server_url, assoc.handle, false)
+
+    # Put assoc back in the store
+    @store.store_association(server_url, assoc)
+
+    # More recent and expires after assoc
+    assoc2 = _gen_assoc(issued_at=1)
+    @store.store_association(server_url, assoc2)
+
+    # After storing an association with a different handle, but the
+    # same server_url, the handle with the later expiration is returned.
+    _check_retrieve(server_url, nil, assoc2)
+
+    # We can still retrieve the older association
+    _check_retrieve(server_url, assoc.handle, assoc)
+
+    # Plus we can retrieve the association with the later expiration
+    # explicitly
+    _check_retrieve(server_url, assoc2.handle, assoc2)
+
+    # More recent, and expires earlier than assoc2 or assoc. Make sure
+    # that we're picking the one with the latest issued date and not
+    # taking into account the expiration.
+    assoc3 = _gen_assoc(issued_at=2, lifetime=100)
+    @store.store_association(server_url, assoc3)
+
+    _check_retrieve(server_url, nil, assoc3)
+    _check_retrieve(server_url, assoc.handle, assoc)
+    _check_retrieve(server_url, assoc2.handle, assoc2)
+    _check_retrieve(server_url, assoc3.handle, assoc3)
+
+    _check_remove(server_url, assoc2.handle, true)
+
+    _check_retrieve(server_url, nil, assoc3)
+    _check_retrieve(server_url, assoc.handle, assoc)
+    _check_retrieve(server_url, assoc2.handle, nil)
+    _check_retrieve(server_url, assoc3.handle, assoc3)
+
+    _check_remove(server_url, assoc2.handle, false)
+    _check_remove(server_url, assoc3.handle, true)
+
+    _check_retrieve(server_url, nil, assoc)
+    _check_retrieve(server_url, assoc.handle, assoc)
+    _check_retrieve(server_url, assoc2.handle, nil)
+    _check_retrieve(server_url, assoc3.handle, nil)
+
+    _check_remove(server_url, assoc2.handle, false)
+    _check_remove(server_url, assoc.handle, true)
+    _check_remove(server_url, assoc3.handle, false)
+
+    _check_retrieve(server_url, nil, nil)
+    _check_retrieve(server_url, assoc.handle, nil)
+    _check_retrieve(server_url, assoc2.handle, nil)
+    _check_retrieve(server_url, assoc3.handle, nil)
+
+    _check_remove(server_url, assoc2.handle, false)
+    _check_remove(server_url, assoc.handle, false)
+    _check_remove(server_url, assoc3.handle, false)
+
+    assocValid1 = _gen_assoc(-3600, 7200)
+    assocValid2 = _gen_assoc(-5)
+    assocExpired1 = _gen_assoc(-7200, 3600)
+    assocExpired2 = _gen_assoc(-7200, 3600)
+
+    @store.cleanup_associations
+    @store.store_association(server_url + '1', assocValid1)
+    @store.store_association(server_url + '1', assocExpired1)
+    @store.store_association(server_url + '2', assocExpired2)
+    @store.store_association(server_url + '3', assocValid2)
+
+    cleaned = @store.cleanup_associations().select{|n|n}.size
+    assert_equal(2, cleaned, "cleaned up associations")
+  end
+
+  # ============================================================================
+  # am including open id here because the nonce module is not being mocked
+  # ============================================================================
+  include OpenID
+
+  # ============================================================================
+  # TESTS BELOW BROUGHT FROM THE ORIGINAL 'ruby-openid' (store) test suite
+  # these methods test the nonce interactivity with a store object
+  # ============================================================================
+
+  def _check_use_nonce(nonce, expected, server_url, msg='')
+    stamp, salt = Nonce::split_nonce(nonce)
+    actual = @store.use_nonce(server_url, stamp, salt)
+    assert_equal(expected, actual, msg)
+  end
+
+  def test_nonce
+    server_url = "http://www.myopenid.com/openid"
+    [server_url, ''].each{|url|
+      nonce1 = Nonce::mk_nonce
+
+      _check_use_nonce(nonce1, true, url, "#{url}: nonce allowed by default")
+      _check_use_nonce(nonce1, false, url, "#{url}: nonce not allowed twice")
+      _check_use_nonce(nonce1, false, url, "#{url}: nonce not allowed third time")
+
+      # old nonces shouldn't pass
+      old_nonce = Nonce::mk_nonce(3600)
+      _check_use_nonce(old_nonce, false, url, "Old nonce #{old_nonce.inspect} passed")
+
+    }
+
+    now = Time.now.to_i
+    old_nonce1 = Nonce::mk_nonce(now - 20000)
+    old_nonce2 = Nonce::mk_nonce(now - 10000)
+    recent_nonce = Nonce::mk_nonce(now - 600)
+
+    orig_skew = Nonce.skew
+    Nonce.skew = 0
+    count = @store.cleanup_nonces
+    Nonce.skew = 1000000
+    ts, salt = Nonce::split_nonce(old_nonce1)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce1")
+    ts, salt = Nonce::split_nonce(old_nonce2)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce2")
+    ts, salt = Nonce::split_nonce(recent_nonce)
+    assert(@store.use_nonce(server_url, ts, salt), "recent_nonce")
+
+
+    Nonce.skew = 1000
+    cleaned = @store.cleanup_nonces.select{|n|n}.size
+    assert_equal(2, cleaned, "Cleaned #{cleaned} nonces")
+
+    Nonce.skew = 100000
+    ts, salt = Nonce::split_nonce(old_nonce1)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce1 after cleanup")
+    ts, salt = Nonce::split_nonce(old_nonce2)
+    assert(@store.use_nonce(server_url, ts, salt), "oldnonce2 after cleanup")
+    ts, salt = Nonce::split_nonce(recent_nonce)
+    assert(!@store.use_nonce(server_url, ts, salt), "recent_nonce after cleanup")
+
+    Nonce.skew = orig_skew
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'active_support'
+require 'couchrest_model'
+require 'openid/store/couch_rest_model'
+require 'openid/store/nonce'
+
+# CouchRest::Model::Base.configure do |conf|
+#   conf.connection[:name] = 'openidcouchrestmodelstoretest'
+# end
+
+Dir['app/models/*.rb'].each do |model|
+  require File.expand_path(model)
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: openid_couch_rest_model_store
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- James Tucker
+- Kazuyoshi Tlacaelel
+- Jeff Gran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &2156431940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156431940
+description: A CouchRestModel store for OpenID, forked from a very similar ActiveRecord
+  store written by James Tucker and Kazuyoshi Tlacaelel
+email: info@wildfireapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- app/models/openid_association.rb
+- app/models/openid_nonce.rb
+- lib/openid/store/couch_rest_model.rb
+- lib/openid_couch_rest_model_store.rb
+- test/openid_store_couch_rest_model_test.rb
+- test/test_helper.rb
+homepage: http://github.com/jeffgran/openid_couch_rest_model_store
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: A CouchRestModel store for OpenID
+test_files: []