ruby-yadis 0.2.2 → 0.3

data/INSTALL

@@ -17,6 +17,6 @@ Make sure everything installed ok:
 
 == Run the test suite
 
-Go into the test directory and execute the *runtests* script.
+Go into the test directory and execute the *runtests.rb* script.
 
 

data/lib/yadis.rb

@@ -1 +1,6 @@
 require 'yadis/yadis'
+require 'yadis/xrds'
+require 'yadis/service'
+require 'yadis/parsehtml'
+require 'yadis/fetcher'
+require 'yadis/manager'

data/lib/yadis.rb~

@@ -0,0 +1 @@
+require 'yadis/yadis'

data/lib/yadis/fetcher.rb

@@ -1,5 +1,13 @@
 require "uri"
-require "net/https"
+
+begin
+  require "net/https"
+rescue LoadError
+  HAS_OPENSSL_ = false
+  require 'net/http'
+else  
+  HAS_OPENSSL_ = true
+end
 
 class NetHTTPFetcher
     
@@ -22,29 +30,31 @@ class NetHTTPFetcher
   
   protected
     
-    # return a Net::HTTP object ready for use
-    
+    # return a Net::HTTP object ready for use    
     def get_http_obj(uri)
       http = Net::HTTP.new(uri.host, uri.port)
       http.read_timeout = @read_timeout
       http.open_timeout = @open_timeout
 
-      if uri.scheme == 'https'
-        http.use_ssl = true
-        if @ca_path
-          http.ca_file = @ca_path
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      if uri.scheme == 'https'        
+        if HAS_OPENSSL_
+          http.use_ssl = true
+          if @ca_path
+            http.ca_file = @ca_path
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            STDERR.puts("Warning: fetching over https without verifying server certificate")
+          end
         else
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          STDERR.puts("Warning: fetching over https without verifying server certificate")
+          STDERR.puts('Warning: trying to fetch HTTPS URL without OpenSSL support')
         end
       end
 
-      http
+      return http
     end
     
-    # do a GET following redirects limit deep
-    
+    # do a GET following redirects limit deep    
     def do_get(url, params, limit=5)
       if limit == 0
         return nil
@@ -57,10 +67,12 @@ class NetHTTPFetcher
         nil
       else
         case resp
-          when Net::HTTPSuccess then [resp, URI.parse(url).to_s]
-          when Net::HTTPRedirection then do_get(resp["location"], params, limit-1)
-          else
-            nil
+        when Net::HTTPSuccess
+          return [resp, URI.parse(url).to_s]
+        when Net::HTTPRedirection
+          return do_get(resp["location"], params, limit-1)
+        else
+          return nil
         end
       end
     end

data/lib/yadis/fetcher.rb~

@@ -0,0 +1,79 @@
+require "uri"
+
+begin
+  require "net/https"
+rescue LoadError
+  HAS_OPENSSL_ = false
+  require 'net/http'
+else  
+  HAS_OPENSSL_ = true
+end
+
+class NetHTTPFetcher
+    
+  attr_accessor :ca_path
+  
+  def initialize(read_timeout=20, open_timeout=20)
+    @read_timeout = read_timeout
+    @open_timeout = open_timeout
+    @ca_path = nil
+  end
+    
+  def get(url, params = nil)    
+    resp, final_url = do_get(url, params)
+    if resp.nil?
+      nil
+    else
+      [final_url, resp]
+    end
+  end
+  
+  protected
+    
+    # return a Net::HTTP object ready for use    
+    def get_http_obj(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = @read_timeout
+      http.open_timeout = @open_timeout
+
+      if uri.scheme == 'https'        
+        if HAS_OPENSSL_
+          http.use_ssl = true
+          if @ca_path
+            http.ca_file = @ca_path
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            STDERR.puts("Warning: fetching over https without verifying server certificate")
+          end
+        else
+          STDERR.puts('Warning: trying to fetch HTTPS URL without OpenSSL support')
+        end
+      end
+
+      return http
+    end
+    
+    # do a GET following redirects limit deep    
+    def do_get(url, params, limit=5)
+      if limit == 0
+        return nil
+      end
+      begin
+        uri = URI.parse(url)
+        http = get_http_obj(uri)
+        resp = http.request_get(uri.request_uri, params)
+      rescue
+        nil
+      else
+        case resp
+        when Net::HTTPSuccess then [resp, URI.parse(url).to_s]
+        when Net::HTTPRedirection then do_get(resp["location"], params, limit-1)
+        else
+          STDERR.puts("ERROR, what to do with #{resp}")
+          nil
+        end
+      end
+    end
+
+end

data/lib/yadis/manager.rb

@@ -0,0 +1,145 @@
+require 'yadis/yadis'
+
+class YadisServiceManager
+
+  attr_reader :starting_url, :yadis_url, :services, :session_key, :current
+
+  def initialize(starting_url, yadis_url, services)
+    @starting_url = starting_url
+    @yadis_url = yadis_url
+    @services = services
+    @current = nil
+  end
+
+  def next
+    @current = @services.shift
+  end
+
+  def for_url?(url)
+    url == @starting_url or url == @yadis_url
+  end
+
+  def started?
+    not @current.nil?
+  end
+
+  def length
+    @services.length
+  end
+
+end
+
+class Discovery
+
+  @@default_suffix = 'auth'
+  @@prefix = '_yadis_services_'
+
+  # expects a normalized url
+  def initialize(session, url, session_key_suffix=nil)
+    @session = session
+    @url = url
+    @session_key = @@prefix + (session_key_suffix or @@default_suffix)
+  end
+
+  def next_service
+    manager = self.get_manager
+    if manager and manager.length <= 0
+      self.destroy_manager
+      manager = nil
+    end
+
+    unless manager
+      begin
+        yadis_url, services = self.discover
+      rescue YADISParseError, YADISHTTPError
+        manager = nil
+      else
+        manager = self.create_manager(services, yadis_url)   
+      end     
+    end
+
+    if manager
+      service = manager.next
+      self.store_manager(manager)
+    else
+      service = nil
+    end
+    
+    return service
+  end
+
+  def finish
+    manager = self.get_manager
+    return nil unless manager
+
+    service = manager.current
+    self.destroy_manager
+    return service
+  end
+
+  def current
+    manager = self.get_manager
+    return nil unless manager
+    return manager.current
+  end
+
+  def get_manager
+    manager = @session[@session_key]
+
+    # make sure we've got the right manager here
+    if manager and manager.for_url?(@url)
+      return manager
+    end
+
+    return nil
+  end
+
+  def create_manager(services, yadis_url=nil)
+    if self.get_manager
+      raise ArgumentError, "There is already a manager for #{@url}"
+    end
+
+    if services.length > 0
+      manager = YadisServiceManager.new(@url, yadis_url, services)
+      self.store_manager(manager)
+    else
+      manager = nil
+    end
+
+    return manager
+  end
+
+  def destroy_manager
+    if self.get_manager
+      begin
+        @session.delete(@session_key)
+      rescue
+        # sometimes Hash like session objects don't have a delete
+        # method.  We handle that case by assigning nil to the session[key]
+        @session[@session_key] = nil
+      end
+    end
+  end
+
+  def store_manager(manager)
+    @session[@session_key] = manager
+  end
+
+  # The filter argument is a Proc that will be used to call
+  # YADIS.filter_services.  See the documentation for YADIS.filter_services
+  # for more information about writing filters.
+  def discover(filter=nil)
+    y = YADIS.new(@url)
+    
+    # a default filter which sends through everything.  you should
+    # probably consider writing a custom filter and passing it in.
+    unless filter
+      filter = lambda {|s| s}
+    end
+
+    return [y.uri, y.filter_services(filter)]    
+  end
+
+end
+
+

data/lib/yadis/manager.rb~

@@ -0,0 +1,138 @@
+require 'yadis/yadis'
+
+class YadisServiceManager
+
+  attr_reader :starting_url, :yadis_url, :services, :session_key, :current
+
+  def initialize(starting_url, yadis_url, services)
+    @starting_url = starting_url
+    @yadis_url = yadis_url
+    @services = services
+    @current = nil
+  end
+
+  def next
+    @current = @services.shift
+  end
+
+  def for_url?(url)
+    url == @starting_url or url == @yadis_url
+  end
+
+  def started?
+    not @current.nil?
+  end
+
+  def length
+    @services.length
+  end
+
+end
+
+class Discovery
+
+  @@default_suffix = nil
+  @@prefix = '_yadis_services_'
+
+  def initialize(session, url, session_key_siffix=nil)
+    @session = session
+    @url = url
+    @session_key = @@prefix + (session_key_suffix or @@default_suffix)
+  end
+
+  def next_service(discover_block)
+    manager = self.get_manager
+    if manager and manager.length <= 0
+      self.destroy_manager
+      manager = nil
+    end
+
+    unless manager
+      begin
+        yadis_url, services = self.discover
+      rescue YADISParseError, YADISHTTPError
+        manager = nil
+      else
+        manager = self.create_manager(services, yadis_url)   
+      end     
+    end
+
+    if manager
+      service = manager.next
+      self.store_manager(manager)
+    else
+      service = nil
+    end
+    
+    return service
+  end
+
+  def finish
+    manager = self.get_manager
+    return nil unless manager
+
+    service = manager.current
+    self.destroy_manager
+    return service
+  end
+
+  def get_manager
+    manager = @session[@session_key]
+
+    # make sure we've got the right manager here
+    if manager and manager.for_url?(@url)
+      return manager
+    end
+
+    return nil
+  end
+
+  def create_manager(services, yadis_url=nil)
+    if self.get_manager
+      raise ArgumentError, "There is already a manager for #{@url}"
+    end
+
+    if services.length > 0
+      manager = YadisServiceManager.new(@url, yadis_url, services)
+      self.store_manager(manager)
+    else
+      manager = nil
+    end
+
+    return manager
+  end
+
+  def destroy_manager
+    if self.get_manager
+      begin
+        @session.delete(@session_key)
+      rescue
+        # sometimes Hash like session objects don't have a delete
+        # method.  We handle that case by assigning nil to the session[key]
+        @session[@session_key] = nil
+      end
+    end
+  end
+
+  def store_manager(manager)
+    @session[@session_key] = manager
+  end
+
+  # The filter argument is a Proc that will be used to call
+  # YADIS.filter_services.  See the documentation for YADIS.filter_services
+  # for more information about writing filters.
+  def discover(filter=nil)
+    y = YADIS.new(@url)
+    
+    # a default filter which sends through everything.  you should
+    # probably consider writing a custom filter and passing it in.
+    unless filter
+      filter = lambda {|s| s}
+    end
+
+    return [y.url, y.filter_services(filter)]    
+  end
+
+end
+
+

data/lib/yadis/service.rb

@@ -0,0 +1,22 @@
+# Class representing an XRD Service element.  
+class ServiceEndpoint
+
+  attr_accessor :service_types, :uri, :yadis_uri, :element, :yadis
+
+  def initialize
+    @service_types = []
+    @uri = nil
+    @yadis_uri = nil
+    @element = nil
+    @yadis_uri = nil
+  end
+
+  def match_type_uris(type_uris)
+    type_uris.find_all {|t| @service_types.member?(t)}
+  end
+
+  def ==(other)
+    return self.instance_variables == other.instance_variables
+  end
+
+end

data/lib/yadis/service.rb~

@@ -0,0 +1,24 @@
+require 'rexml/document'
+
+# Class representing an XRD Service element.  
+class ServiceEndpoint
+
+  attr_accessor :service_types, :uri, :yadis_uri, :element, :yadis
+
+  def initialize
+    @service_types = []
+    @uri = nil
+    @yadis_uri = nil
+    @element = nil
+    @yadis_uri = nil
+  end
+
+  def match_type_uris(type_uris)
+    type_uris.find_all {|t| @service_types.member?(t)}
+  end
+
+  def ==(other)
+    return self.instance_variables == other.instance_variables
+  end
+
+end

data/lib/yadis/xrds.rb

@@ -1,8 +1,25 @@
 require 'rexml/document'
+require 'yadis/service'
 
 # Class that handles XRDS parsing and XRD Service element extraction.
+
+module XRDSUtil
+
+  @@default_namespace = 'xri://$xrd*($v*2.0)'
+  @@xrds_namespace = {'xrds' => 'xri://$xrds'}
+
+  def last_xrd(root_element)
+    REXML::XPath.match(root_element, '/xrds:XRDS/XRD',
+                       @@xrds_namespace)[-1]
+  end
+  
+end
+
 class XRDS
 
+  include XRDSUtil
+  attr_reader :xml
+
   # Method for producing a valid XRDS object.  Accepts an XML
   # String. Returns an XRDS object on success, or nil on failure.
   # Same as calling XRDS.new, but does not rails ArgumentErrors.
@@ -14,25 +31,24 @@ class XRDS
     end
   end
 
-  def XRDS.parse_verbose(xml)
-    new(xml)
-  end
-
   # Create a new XRDS object.  Raises ArgumentError if xml_text is
   # malformed or invalid XRDS.
   def initialize(xml_text)
+    @xml_text = xml_text
     parse_xml(xml_text)
   end
 
-  # The schema was defined to support multiple XRD elements, but YADIS
-  # will never use it, so we assume just one.
-  #
-  # multiple Type and URI funkiness
-  #
-  # Does not implement URI priority yet.
+  def _dump(depth)
+    return @xml_text
+  end
+
+  def XRDS._load(s)
+    XRDS.new(s)
+  end
+
   def parse_xml(xml_text)   
     begin
-      xml = REXML::Document.new(xml_text)
+      xml = @xml = REXML::Document.new(xml_text)
     rescue
       raise ArgumentError, "Can't parse XRDS"
     end
@@ -41,36 +57,25 @@ class XRDS
       raise ArgumentError, "No document root"
     end
     
-    if xml.root.attributes['xmlns'] != 'xri://$xrd*($v*2.0)'
-      raise ArgumentError, "Unknown XRID version #{xml.root.attributes['xmlns'].to_s}"
-    end
-
-    # get the last <XRD> element
-    xrd_elemets = xml.root.get_elements('/xrds:XRDS/XRD')
-    last_xrd = xrd_elemets[-1]    
-    if last_xrd.nil?
-      raise ArgumentError, "No XRD Elements found"
+    xmlns = xml.root.attributes['xmlns']
+    if xmlns != @@default_namespace
+      raise ArgumentError, "Unknown XRID version #{xmlns.to_s}"
     end
 
-    # get Service elements
-    @services = {}  # keyed by priority
-    priority_index = -1  # for services w/ no priority specified
-    last_xrd.elements.each('Service') do |s|
-      s.elements.each('URI') do |u|
-        priority_index = _create_services(s, u, priority_index)
-      end
-      if !s.elements['URI']
-        priority_index = _create_services(s, nil, priority_index)
-      end
-    end
+    xrd = self.last_xrd(xml.root)
+    raise ArgumentError, "No XRD Elements found" if xrd.nil?
+   
+    @services = {}  # keyed by [service_priority, uri_priority]    
+    xrd.elements.each('Service') {|s| _create_services(s)}
   end
 
-  # Returns an Array of Service objects, sorted by priority.  Highest
+
+  # Returns an Array of ServiceEndpoint objects, sorted by priority.  Highest
   # priority is at element 0.
   def services
     s = []
 
-    @services.keys.sort.each do |key| @services[key]
+    @services.keys.sort.each do |key|
       services_list = @services[key].dup
 
       # randomize services with the same priority
@@ -85,61 +90,48 @@ class XRDS
 
   private
 
-  def _add_service(priority_index, service)
-    unless @services.has_key?(priority_index)
-      @services[priority_index] = []
-    end
-
-    # services with the same priority are appended to the list
-    @services[priority_index] << service
-  end
-
   # create services objects
-  def _create_services(service_element, uri_element, priority_index)
-    service_element.elements.each('Type') do |t|
-      service = Service.new
-      service.uri = uri_element.text if uri_element
-      service.service_type = t.text
-      service.element = service_element
-      
-      service_element.elements.each do |e|
-        service.add_other(e.prefix + ':' + e.name, e.text) if e.prefix
-      end
-      
-      if service_element.attributes['priority']
-        priority = service_element.attributes['priority'].to_i
-        _add_service(priority, service)
+  def _create_services(service_element)
+    service = ServiceEndpoint.new
+    service.element = service_element
+    service.uri = nil
+    service.service_types = []
 
-      elsif uri_element.attributes['priority']
-        priority = uri_element.attributes['priority'].to_i
-        _add_service(priority, service)
+    service_element.elements.each('Type') do |t|
+      service.service_types << t.text.strip 
+    end
 
-      else
-        _add_service(priority_index, service)
-        priority_index -= 1
+    sp = service_element.attributes['priority']
+    service_priority = sp ? sp.to_i : -1
+
+    if service.element.elements['URI']
+      service.element.elements.each('URI') do |uri|
+        _service = service.dup
+        _service.uri = uri.text.strip
+        
+        up = uri.attributes['priority']
+        uri_priority = up ? up.to_i : -1
+        priority = [service_priority, uri_priority]
+        
+        _add_service(priority, _service)
       end
+      
+    else
+      priority = [service_priority, -1]
+      _add_service(priority, service)
 
     end
 
-    return priority_index
   end
 
-end
-
-# Class representing an XRD Service element.  
-class Service
-  attr_reader :service_type, :uri, :element
-  attr_writer :service_type, :uri, :element
-
-  def initialize
-    @other = Hash.new
-  end
+  def _add_service(priority, service)
+    unless @services.has_key?(priority)
+      @services[priority] = []
+    end
 
-  def add_other(name, value)
-    @other[name] = value
+    # services with the same priority are appended to the list
+    @services[priority] << service
   end
 
-  def other
-    return @other
-  end
 end
+

data/lib/yadis/xrds.rb~

@@ -0,0 +1,128 @@
+require 'rexml/document'
+require 'yadis/service'
+
+# Class that handles XRDS parsing and XRD Service element extraction.
+
+module XRDSUtil
+
+  @@default_namespace = 'xri://$xrd*($v*2.0)'
+  @@xrds_namespace = {'xrds' => 'xri://$xrds'}
+
+  def last_xrd(root_element)
+    REXML::XPath.match(root_element, '/xrds:XRDS/XRD',
+                       @@xrds_namespace)[-1]
+  end
+  
+end
+
+class XRDS
+
+  include XRDSUtil
+  attr_reader :xml
+
+  # Method for producing a valid XRDS object.  Accepts an XML
+  # String. Returns an XRDS object on success, or nil on failure.
+  # Same as calling XRDS.new, but does not rails ArgumentErrors.
+  def XRDS.parse(xml)
+    begin
+      return new(xml)
+    rescue
+      return nil
+    end
+  end
+
+  # Create a new XRDS object.  Raises ArgumentError if xml_text is
+  # malformed or invalid XRDS.
+  def initialize(xml_text)
+    parse_xml(xml_text)
+  end
+
+  def parse_xml(xml_text)   
+    begin
+      xml = @xml = REXML::Document.new(xml_text)
+    rescue
+      raise ArgumentError, "Can't parse XRDS"
+    end
+    
+    if xml.root.nil?
+      raise ArgumentError, "No document root"
+    end
+    
+    xmlns = xml.root.attributes['xmlns']
+    if xmlns != @@default_namespace
+      raise ArgumentError, "Unknown XRID version #{xmlns.to_s}"
+    end
+
+    xrd = self.last_xrd(xml.root)
+    raise ArgumentError, "No XRD Elements found" if xrd.nil?
+   
+    @services = {}  # keyed by [service_priority, uri_priority]    
+    xrd.elements.each('Service') {|s| _create_services(s)}
+  end
+
+
+  # Returns an Array of ServiceEndpoint objects, sorted by priority.  Highest
+  # priority is at element 0.
+  def services
+    s = []
+
+    @services.keys.sort.each do |key|
+      services_list = @services[key].dup
+
+      # randomize services with the same priority
+      while services_list.length > 0
+        s << services_list.delete_at((rand * services_list.length).to_i)
+      end
+
+    end
+    
+    return s
+  end
+
+  private
+
+  # create services objects
+  def _create_services(service_element)
+    service = ServiceEndpoint.new
+    service.element = service_element
+    service.uri = nil
+    service.service_types = []
+
+    service_element.elements.each('Type') do |t|
+      service.service_types << t.text.strip 
+    end
+
+    sp = service_element.attributes['priority']
+    service_priority = sp ? sp.to_i : -1
+
+    if service.element.elements['URI']
+      service.element.elements.each('URI') do |uri|
+        _service = service.dup
+        _service.uri = uri.text.strip
+        
+        up = uri.attributes['priority']
+        uri_priority = up ? up.to_i : -1
+        priority = [service_priority, uri_priority]
+        
+        _add_service(priority, _service)
+      end
+      
+    else
+      priority = [service_priority, -1]
+      _add_service(priority, service)
+
+    end
+
+  end
+
+  def _add_service(priority, service)
+    unless @services.has_key?(priority)
+      @services[priority] = []
+    end
+
+    # services with the same priority are appended to the list
+    @services[priority] << service
+  end
+
+end
+

data/lib/yadis/yadis.rb

@@ -5,14 +5,18 @@ require 'yadis/parsehtml'
 class YADISParseError < StandardError; end
 class YADISHTTPError < StandardError; end
 
+
+# High level class for performing the Yadis protocol on a given URL. The
+# YADIS.discover class method is a good place to get started in determining
+# which services a URL supports.
 class YADIS
 
   @@ca_path = nil
   attr_accessor :uri, :xrds_uri, :xrds
 
   # Discover services for a given URI.  Please note that no normalization 
-  # will be done to the passed in URI, it should be valid before calling
-  # discover.
+  # will be done to the passed in URI, it should be a textually
+  # valid URI string before calling discover.
   #
   # Returns nil if no XRDS was found, or a YADIS object on success.  This
   # method is essentially the same as YADIS.new, but does not raise any
@@ -46,9 +50,9 @@ class YADIS
   # or YADISHTTPError is the URI cannot be fetched.
   def initialize(uri)
     http = NetHTTPFetcher.new
-    http.ca_path = @@ca_path if @@ca_path
-    
+    http.ca_path = @@ca_path if @@ca_path    
     headers = {'Accept' => 'application/xrds+xml'}
+
     response = http.get(uri, headers)
     raise YADISHTTPError, "Could not fetch #{uri}" if response.nil?
 
@@ -82,34 +86,23 @@ class YADIS
 
   # Returns an Array Service objects sorted by priority.
   def services
+    @xrds.services.each {|s| s.yadis = self}
     @xrds.services
   end
 
-  # Returns an Array of Service objects that represent OpenID servers,
-  # sorted by priority.
-  #
-  # Optionally accpets an Array of OpenID protocol versions.Versions
-  # should be given as strings eg: '1.0'
-  def openid_servers(versions=nil)
-    versions.collect! {|v| v.gsub('.', '\.')} if versions
-
-    base_url = 'http://openid.net/signon/'
-    base_url += '(' + versions.join('|') + '){1}' if versions
+  # Returns a list of services, ordered by priority,
+  # that match the filter. filter is a Proc object that produces
+  # ServiceEnpoint objects, subclasses of ServiceEnpoint or nil.
+  # This method is useful for extracting several types of services while
+  # maintaining priority, for example you may write a filter Proc to extract
+  # OpenID and LID ServiceEnpoint objects.
+  def filter_services(filter)
+    # product a list of filtered ServiceEndpoint objects.  filtered
+    # will contain a list of nil or ServiceEnpoint (subclasses) objects.
+    filtered = self.services.collect {|s| filter.call(s)}
     
-    return @xrds.services.find_all {|s| s.service_type.match(base_url)}
+    # return all object in filtered that are not nil
+    return filtered.find_all {|s| s}
   end
 
-  # Returns an Array of Service objects that represent LID servers,
-  # sorted by priority.
-  #
-  # Optionally accpets an Array of LID protocol versions.Versions
-  # should be given as strings eg: '1.0'
-  def lid_servers(versions)
-    versions.collect! {|v| v.gsub('.', '\.')} if versions
-    
-    base_url = 'http://lid.netmesh.org/sso/'
-    base_url += '(' + versions.join('|') + '){1}' if versions
-
-    return @xrds.services.find_all {|s| s.service_type.match(base_url)}
-  end
 end

data/lib/yadis/yadis.rb~

@@ -0,0 +1,104 @@
+require 'yadis/xrds'
+require 'yadis/fetcher'
+require 'yadis/parsehtml'
+
+class YADISParseError < StandardError; end
+class YADISHTTPError < StandardError; end
+
+class YADIS
+
+  @@ca_path = nil
+  attr_accessor :uri, :xrds_uri, :xrds
+
+  # Discover services for a given URI.  Please note that no normalization 
+  # will be done to the passed in URI, it should be a textually
+  # valid URI string before calling discover.
+  #
+  # Returns nil if no XRDS was found, or a YADIS object on success.  This
+  # method is essentially the same as YADIS.new, but does not raise any
+  # exceptions.
+  def YADIS.discover(uri)
+    return nil unless uri
+    begin
+      return YADIS.new(uri)
+    rescue
+      return nil
+    end
+  end
+
+  # Set the path to a certificate authority pem file, for verifying
+  # server certificates of HTTPS pages.  If you are interested in verifying
+  # certs like the mozilla web browser, have a look at the files here:
+  #
+  # http://curl.haxx.se/docs/caextract.html
+  def YADIS.ca_path=(ca_path)
+    ca_path = ca_path.to_s
+    if File.exists?(ca_path)
+      @@ca_path = ca_path
+    else
+      raise ArgumentError, "#{ca_path} is not a valid file path"
+    end
+  end
+
+  # Discover services for a URI using the Yadis protocol.  +uri+ should
+  # be a valid URI represented as a string.  This method may raise
+  # YADISParseError in the case of an invalid or unparsable XRDS file,
+  # or YADISHTTPError is the URI cannot be fetched.
+  def initialize(uri)
+    http = NetHTTPFetcher.new
+    http.ca_path = @@ca_path if @@ca_path    
+    headers = {'Accept' => 'application/xrds+xml'}
+
+    response = http.get(uri, headers)
+    raise YADISHTTPError, "Could not fetch #{uri}" if response.nil?
+
+    uri, resp_payload = response
+    xrds_uri = uri
+
+    header = resp_payload['x-xrds-location']
+    header = resp_payload['x-yadis-location'] if header.nil?
+
+    if header
+      xrds_uri = header
+      response = http.get(xrds_uri)
+      raise YADISHTTPError, "Could not fetch XRDS #{xrds_uri}" if response.nil?
+      resp_payload = response[1]
+    end
+
+    unless resp_payload['content-type'] == 'application/xrds+xml'
+      loc = html_yadis_location(resp_payload.body)
+      unless loc.nil?
+        xrds_uri, resp_payload = http.get(loc)
+      end
+    end
+
+    xrds = XRDS.parse(resp_payload.body)
+    raise YADISParseError, "Bad XRDS" if xrds.nil?
+
+    @uri = uri
+    @xrds_uri = xrds_uri
+    @xrds = xrds
+  end
+
+  # Returns an Array Service objects sorted by priority.
+  def services
+    @xrds.services.each {|s| s.yadis = self}
+    @xrds.services
+  end
+
+  # Returns a list of services, ordered by priority,
+  # that match the filter. filter is a Proc object that produces
+  # ServiceEnpoint objects, subclasses of ServiceEnpoint or nil.
+  # This method is useful for extracting several types of services while
+  # maintaining priority, for example you may write a filter Proc to extract
+  # OpenID and LID ServiceEnpoint objects.
+  def filter_services(filter)
+    # product a list of filtered ServiceEndpoint objects.  filtered
+    # will contain a list of nil or ServiceEnpoint (subclasses) objects.
+    filtered = self.services.collect {|s| filter.call(s)}
+    
+    # return all object in filtered that are not nil
+    return filtered.find_all {|s| s}
+  end
+
+end

data/test/test_discovery.rb

@@ -39,4 +39,9 @@ class DiscoveryTestCase < Test::Unit::TestCase
     assert_nil(YADIS.discover('http://google.com/?q=huh'))
   end
 
+  def test_marshal
+    y = YADIS.discover('http://brian.myopenid.com/')
+    Marshal.dump(y)
+  end
+
 end

data/test/test_xrds.rb

@@ -5,26 +5,25 @@ class XRDSTestCase < Test::Unit::TestCase
 
   def test_xrds_good
     File.open('data/brian.xrds') do |f|
-      xrds = XRDS.parse(f.read)
+      xrds = XRDS.new(f.read)
       assert_not_nil(xrds)
       assert_equal(xrds.services.length, 1)      
     end
   end
 
-
   def test_xrds_good_multi
     File.open('data/brian.multi.xrds') do |f|
-      xrds = XRDS.parse(f.read)
+      xrds = XRDS.new(f.read)
       assert_not_nil(xrds)
       assert_equal(1, xrds.services.length)      
       s = xrds.services[0]
-      assert_equal('http://openid.net/signon/1.0', s.service_type)
+      assert s.service_types.member?('http://openid.net/signon/1.0')
     end
   end
 
   def test_xrds_good_uri_multi
     File.open('data/brian.multi_uri.xrds') do |f|
-      xrds = XRDS.parse(f.read)
+      xrds = XRDS.new(f.read)
       assert_not_nil(xrds)
       assert_equal(2, xrds.services.length)
     end
@@ -38,4 +37,13 @@ class XRDSTestCase < Test::Unit::TestCase
     assert_nil(XRDS.parse('\000'))
   end
 
+  def test_marshal
+    File.open('data/brian.xrds') do |f|
+      xrds = XRDS.new(f.read)
+      s = Marshal.dump(xrds)
+      xrds2 = Marshal.load(s)
+      assert_equal(xrds.services, xrds2.services)
+    end   
+  end
+
 end

data/test/test_yadis.rb

@@ -3,44 +3,6 @@ require 'yadis'
 
 class YADISTestCase < Test::Unit::TestCase
 
-  def test_yadis_openid
-    File.open('data/brian.xrds') do |f|      
-      xrds = XRDS.parse(f.read)
-
-      assert_not_nil(xrds)
-      assert_equal(xrds.services.length, 1)
-
-      uri = 'http://brian.myopenid.com/'
-      xrds_uri = 'http://brian.myopenid.com/xrds'
-      y = YADIS.new(uri)
-      y.uri = uri
-      y.xrds_uri = xrds_uri
-      y.xrds_uri = xrds
-      
-      servers = y.openid_servers
-      assert_equal(servers.length, 1)
-
-      myopenid = servers[0]
-      assert_equal(myopenid.service_type, 'http://openid.net/signon/1.0')
-      assert_equal(myopenid.uri, 'http://www.myopenid.com/server')
-      assert_equal(myopenid.other['openid:Delegate'],  'http://brian.myopenid.com/')
-
-      servers = y.openid_servers(['1.0'])
-      assert_equal(servers.length, 1)
-
-      myopenid = servers[0]
-      assert_equal(myopenid.service_type, 'http://openid.net/signon/1.0')
-      assert_equal(myopenid.uri, 'http://www.myopenid.com/server')
-      assert_equal(myopenid.other['openid:Delegate'],  'http://brian.myopenid.com/')
-
-      servers = y.openid_servers(['0.9'])
-      assert_equal(servers.length, 0)
-
-      servers = y.openid_servers(['0.9', '1.1'])
-      assert_equal(servers.length, 0)
-    end
-  end
-
   def test_yadis_lid
     # need an xrds with lid stuff in it for this part
   end
@@ -49,8 +11,8 @@ class YADISTestCase < Test::Unit::TestCase
     xrds = XRDS.parse(File.open('data/brian_priority.xrds').read)    
     assert_equal(2, xrds.services.length)
     assert_equal('http://www.myopenid.com/server', xrds.services[0].uri)
-    assert_equal('http://www.schtuff.com/?action=openid_server', xrds.services[1].uri)
-
+    assert_equal('http://www.schtuff.com/?action=openid_server',
+                 xrds.services[1].uri)
   end
 
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby-yadis
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2006-03-22 00:00:00 -08:00
+  version: "0.3"
+date: 2006-05-10 00:00:00 -07:00
 summary: A library for performing Yadis service discovery
 require_paths: 
 - lib
@@ -31,11 +31,19 @@ files:
 - examples/openid.rb
 - lib/yadis.rb
 - lib/yadis
+- lib/yadis.rb~
 - lib/yadis/parsehtml.rb
 - lib/yadis/xrds.rb
 - lib/yadis/yadis.rb
 - lib/yadis/fetcher.rb
 - lib/yadis/htmltokenizer.rb
+- lib/yadis/manager.rb
+- lib/yadis/yadis.rb~
+- lib/yadis/service.rb
+- lib/yadis/manager.rb~
+- lib/yadis/service.rb~
+- lib/yadis/xrds.rb~
+- lib/yadis/fetcher.rb~
 - test/test_parse.rb
 - test/data
 - test/test_discovery.rb