ruby-openid 1.1.1 → 1.1.2

data/lib/openid/discovery.rb~

@@ -1,122 +0,0 @@
-require "openid/util"
-require "openid/service"
-require "openid/parse"
-
-# try and use the yadis gem, falling back to system yadis
-begin
-  require 'rubygems'
-  require_gem 'ruby-yadis', ">=0.4"  
-rescue LoadError
-  require "yadis"
-end
-
-module OpenID
-
-  OPENID_IDP_2_0_TYPE = 'http://openid.net/server/2.0'
-  OPENID_2_0_TYPE = 'http://openid.net/signon/2.0'
-  OPENID_1_2_TYPE = 'http://openid.net/signon/1.2'
-  OPENID_1_1_TYPE = 'http://openid.net/signon/1.1'
-  OPENID_1_0_TYPE = 'http://openid.net/signon/1.0'
-  OPENID_TYPE_URIS = [OPENID_2_0_TYPE,OPENID_1_2_TYPE,
-                     OPENID_1_1_TYPE,OPENID_1_0_TYPE]
-
-  # OpenID::Discovery encapsulates the logic for doing Yadis and OpenID 1.0
-  # style server discovery.  This class uses a session object to manage 
-  # a list of tried OpenID servers for implemeting server fallback.  This is
-  # useful the case when a user's primary server(s) is not available, and
-  # will allow then to try again with one of their alternates.
-  class OpenIDDiscovery < Discovery
-
-    def initialize(session, url, fetcher, suffix=nil)
-      super(session, url, suffix)
-      @fetcher = fetcher
-    end
-
-    # Pass in a custom filter here if you like.  Otherwise you'll get all
-    # OpenID sso services. filter should produce objects or subclasses of
-    # OpenIDServiceEndpoint.
-    def discover(filter=nil)
-      unless filter
-        filter = lambda {|s| OpenIDServiceEndpoint.from_endpoint(s)}
-      end
-      
-      begin
-        # do yadis discover, filtering out OpenID services
-        return super(filter)
-      rescue YADISParseError, YADISHTTPError
-
-        # Couldn't do Yadis discovery, fall back on OpenID 1.0 disco
-        status, service = self.openid_discovery(@url)
-        if status == SUCCESS
-          return [service.consumer_id, [service]]
-        end
-      end
-
-      return [nil, []]
-    end
-
-    # Perform OpenID 1.0 style link rel discovery.  No string normalization
-    # will be done on +url+.  See Util.normalize_url for information on
-    # textual URL transformations.
-    def openid_discovery(url)
-      ret = @fetcher.get(url)
-      return [HTTP_FAILURE, nil] if ret.nil?
-      
-      consumer_id, data = ret
-      server = nil
-      delegate = nil
-      parse_link_attrs(data) do |attrs|
-        rel = attrs["rel"]
-        if rel == "openid.server" and server.nil?
-          href = attrs["href"]
-          server = href unless href.nil?
-        end
-        
-        if rel == "openid.delegate" and delegate.nil?
-          href = attrs["href"]
-          delegate = href unless href.nil?
-        end
-      end
-
-      return [PARSE_ERROR, nil] if server.nil?
-    
-      server_id = delegate.nil? ? consumer_id : delegate
-
-      consumer_id = OpenID::Util.normalize_url(consumer_id)
-      server_id = OpenID::Util.normalize_url(server_id)
-      server_url = OpenID::Util.normalize_url(server)
-                  
-      service = OpenID::FakeOpenIDServiceEndpoint.new(consumer_id,
-                                                      server_id,
-                                                      server_url)
-      return [SUCCESS, service]
-    end    
-
-  end
-
-  class XRIDiscovery < Discovery
-    def initialize(session, iname, suffix=nil)
-      super(session, iname, suffix)
-    end
-
-    def discover(filter=nil)
-      begin
-        services = XRI::ProxyResolver.new.query(@url, OPENID_TYPE_URIS)
-      rescue XRI::XRIHTTPError, ArgumentError
-        return [nil, []]
-      end
-      endpoints = []
-      services.each {|s|
-        se = OpenIDServiceEndpoint.from_endpoint(s)
-        if se
-          se.delegate_url = @url
-          se.yadis_url = @url
-          endpoints << se
-        end
-      }
-      return [@url, endpoints]      
-    end
-
-  end
-
-end

data/lib/openid/stores.rb~

@@ -1,178 +0,0 @@
-require "openid/util"
-
-module OpenID
-
-  # Interface for the abstract Store
-  class Store
-
-    @@AUTH_KEY_LEN = 20
-
-    # Put a Association object into storace
-    def store_association(association)
-      raise NotImplementedError
-    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)
-      raise NotImplementedError
-    end
-
-    # If there is a matching association, remove it from the store and
-    # return true, otherwise return false.
-    def removeAssociation(server_url, handle)
-      raise NotImplementedError
-    end
-
-    # Stores a nonce (which is passed in as a string).
-    def store_nonce(nonce)
-      raise NotImplementedError
-    end
-
-    # If the nonce is in the store, remove it and return true. Otherwise
-    # return false.
-    def use_nonce(nonce)
-      raise NotImplementedError
-    end
-
-    # Returns a 20-byte auth key used to sign the tokens, to ensure
-    # that they haven't been tampered with in transit. It must return
-    # the same key every time it is called.   
-    def get_auth_key
-      raise NotImplementedError
-    end
-
-    # Method return true if the store is dumb-mode-style store.
-    def dumb?
-      false
-    end
-
-  end
-
-
-  class DumbStore < Store
-    
-    def initialize(secret_phrase)
-      require "digest/sha1"
-      @auth_key = Digest::SHA1.hexdigest(secret_phrase)
-    end
-
-    def store_association(assoc)
-      nil
-    end
-
-    def get_association(server_url)
-      nil
-    end
-  
-    def remove_association(server_url, handle)
-      false
-    end
-
-    def store_nonce(nonce)
-      nil
-    end
-
-    def use_nonce(nonce)
-      true
-    end
-
-    def get_auth_key
-      @auth_key
-    end
-
-    def dumb?
-      true
-    end
-
-  end
-
-  class ServerAssocs
-    def initialize
-      @assocs = {}
-    end
-
-    def set(assoc)
-      @assocs[assoc.handle] = assoc
-    end
-
-    def get(handle)
-      @assocs[handle]
-    end
-
-    def remove(handle)
-      return @assocs.delete(handle)
-    end
-
-    def best
-      best = nil
-      @assocs.each do |k, assoc|
-        if best.nil? or best.issued < assoc.issued
-          best = assoc
-        end
-      end
-      return best
-    end
-  end
-
-  # An in-memory implementation of Store.  This class is mainly used
-  # for testing, though it may be useful for long-running single process apps.
-  #
-  # You should probably be looking at OpenID::FilesystemStore
-  class MemoryStore < Store
-
-    def initialize
-      @server_assocs = {}
-      @nonces = {}
-      @auth_key = OpenID::Util.random_string(@@AUTH_KEY_LEN)
-    end
-
-    def dumb?
-      false
-    end
-
-    def store_association(server_url, assoc)
-      assocs = _get_server_assocs(server_url)
-      assocs.set(self.deepcopy(assoc))
-    end
-    
-    def get_association(server_url, handle=nil)
-      assocs = _get_server_assocs(server_url)
-      return assocs.best if handle.nil?
-      return assocs.get(handle)
-    end
-    
-    def remove_association(server_url, handle)
-      assocs = _get_server_assocs(server_url)
-      return assocs.remove(handle)
-    end
-
-    def use_nonce(nonce)
-      return true if @nonces.delete(nonce)
-      return false
-    end
-
-    def store_nonce(nonce)
-      @nonces[nonce] = true
-    end
-
-    def get_auth_key
-      @auth_key
-    end
-
-    def _get_server_assocs(server_url)
-      unless @server_assocs.has_key?(server_url)
-        @server_assocs[server_url] = ServerAssocs.new
-      end
-      return @server_assocs[server_url]
-    end
-
-    def deepcopy(o)
-      Marshal.load(Marshal.dump(o))
-    end
-
-  end
-
-end

data/test/teststore.rb~

@@ -1,47 +0,0 @@
-require 'test/unit'
-require 'fileutils'
-require 'pathname'
-require 'tmpdir'
-
-require 'openid/filestore'
-require 'storetestcase'
-
-class FileStoreTestCase < Test::Unit::TestCase
-  include StoreTestCase
-
-  @@dir = Pathname.new(Dir.tmpdir).join('filstoretest')
-
-  def setup
-    FileUtils.rm_rf(@@dir)
-    @store = OpenID::FilesystemStore.new(@@dir)    
-  end
-
-  def teardown
-    FileUtils.rm_rf(@@dir)
-  end
-end
-
-class DumbStoreTestCase < Test::Unit::TestCase
-  include StoreTestCase
-
-  def setup
-    @store = OpenID::DumbStore.new('unit-test')
-  end
-
-  def test_nonce
-    assert_equal(true, @store.use_none('anything'))
-  end
-
-end
-
-class MemoryStoreTestCase < Test::Unit::TestCase
-  include StoreTestCase
-
-  @@dir = Pathname.new(Dir.tmpdir).join('filstoretest')
-
-  def setup
-    @store = OpenID::MemoryStore.new
-  end
-
-end
-