ruby-yadis 0.3.2 → 0.3.3

data/examples/openid.rb

@@ -6,17 +6,22 @@ require 'yadis'
 # Visit http://curl.haxx.se/docs/caextract.html and uncomment:
 # YADIS.ca_path = '/path/to/cacert.pem'
 
-yadis = YADIS.discover('http://brian.myopenid.com/')
-if yadis.nil? or yadis.openid_servers.length == 0
-  p 'No XRDS found'
+url = 'http://brianellin.com/'
+puts "Looking for servers for #{url}\n"
+
+yadis = YADIS.discover(url)
+openid_filter = Proc.new do |service|
+  service.service_types.member?('http://openid.net/signon/1.0') ? service : nil
+end
+
+if yadis.nil?
+  puts 'No XRDS found.'
 else
-  servers = yadis.openid_servers
-  if servers.length == 0
-    p 'No OpenID servers found'
+  services = yadis.filter_services(openid_filter)
+  if services.length > 0
+    services.each {|s| puts "OpenID server found: #{s.uri}"}
   else
-    servers.each do |s|
-      p "OpenID server found: #{s.type}, #{s.uri}"
-    end
+    puts 'No OpenID servers found.'  
   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,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

@@ -1,13 +1,14 @@
 # Class representing an XRD Service element.  
 class ServiceEndpoint
 
-  attr_accessor :service_types, :uri, :yadis_uri, :element, :yadis
+  attr_accessor :service_types, :uri, :yadis_uri, :element, :yadis, :canonical_id
 
   def initialize
     @service_types = []
     @uri = nil
     @yadis_uri = nil
     @element = nil
+    @canonical_id = nil
   end
 
   def match_type_uris(type_uris)

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

@@ -66,6 +66,14 @@ class XRDS
     REXML::XPath.each(xrd, 'xrdns:Service', @@namespaces) do |s|
       _create_services(s)
     end
+    
+    REXML::XPath.each(xrd, 'xrdns:CanonicalID', @@namespaces) do |c|
+      canonical_id = c.text.strip
+      if canonical_id.length > 0
+        self.services.each {|s| s.canonical_id = canonical_id}
+      end
+    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/xri.rb

@@ -0,0 +1,87 @@
+require 'yadis/xrds'
+require 'yadis/fetcher'
+
+# The '(' is for cross-reference authorities, and hopefully has a matching ')'
+# somewhere.
+XRI_AUTHORITIES = ["!", "=", "@", "+", "$", "("]
+
+module XRI
+
+  def XRI.identifier_scheme(identifier)
+    if identifier.match('^xri://') or XRI_AUTHORITIES.member?(identifier[0].chr)
+      return :xri
+    else
+      return :uri
+    end
+  end
+
+  # Transform an XRI reference to an IRI reference.
+  # Note this is not not idempotent, so do not apply this to an identifier more
+  # than once.
+  # XRI Syntax section 2.3.1
+  def XRI.to_iri_normal(xri)
+    iri = xri.dup
+    iri.insert(0, 'xri://') if not iri.match('^xri://')
+    return escape_for_iri(iri)
+  end
+  
+  # Note this is not not idempotent, so do not apply this more than once.
+  # XRI Syntax section 2.3.2
+  def XRI.escape_for_iri(xri)
+    esc = xri.dup
+    # encode all %
+    esc.gsub!(/%/, '%25')
+    esc.gsub!(/\((.*?)\)/) { |xref_match|
+      xref_match.gsub(/[\/\?\#]/) { |char_match|
+        CGI::escape(char_match)
+      }
+    }
+    return esc
+  end
+
+  # Transform an XRI reference to a URI reference.
+  # Note this is not not idempotent, so do not apply this to an identifier more
+  # than once.
+  # XRI Syntax section 2.3.1
+  def XRI.to_uri_normal(xri)
+    return iri_to_uri(to_iri_normal(xri))
+  end
+  
+  # RFC 3987 section 3.1
+  def XRI.iri_to_uri(iri)
+    uri = iri.dup
+    # for char in ucschar or iprivate
+    # convert each char to %HH%HH%HH (as many %HH as octets)
+    return uri
+  end
+
+  def provider_is_authoritative(provider_id, canonical_id)
+    lastbang = canonical_id.rindex('!')
+    return false unless lastbang
+    parent = canonical_id[0...lastbang]
+    return parent == provider_id
+  end
+
+  def root_authority(xri)
+    xri = xri[6..-1] if xri.index('xri://') == 0
+    authority = xri.split('/', 2)[0]
+    if authority[0].chr == '('
+      root = authority[0...authority.index(')')+1]
+    elsif XRI_AUTHORITIES.member?(authority[0].chr)
+      root = authority[0].chr
+    else
+      root = authority.split(/[!*]/)[0]
+    end
+    
+    make_xri(root)
+  end
+
+  
+  def make_xri(xri)
+    if xri.index('xri://') != 0
+      xri = 'xri://' + xri
+    end
+    return xri
+  end
+
+end

data/lib/yadis/xrires.rb

@@ -0,0 +1,94 @@
+require "cgi"
+require "yadis/xri"
+require "yadis/xrds"
+require "yadis/fetcher"
+
+module XRI
+
+  class XRIHTTPError < StandardError; end
+  
+  class ProxyResolver
+
+    DEFAULT_PROXY = 'http://proxy.xri.net/'
+    
+    def initialize(proxy_url=nil)
+      if proxy_url
+        @proxy_url = proxy_url
+      else
+        @proxy_url = DEFAULT_PROXY
+      end
+
+      @proxy_url += '/' unless @proxy_url.match('/$')
+    end
+
+    def query_url(xri, service_type=nil)
+      # URI normal form has a leading xri://, but we need to strip
+      # that off again for the QXRI.  This is under discussion for
+      # XRI Resolution WD 11.
+      # 
+      qxri = XRI.to_uri_normal(xri)[6..-1]
+      hxri = @proxy_url + qxri
+      args = {'_xrd_r' => 'application/xrds+xml'}
+      if service_type
+        args['_xrd_t'] = service_type
+      else
+        # don't perform service endpoint selection 
+        args['_xrd_r'] += ';sep=false'
+      end
+
+      return XRI.append_args(hxri, args)
+    end
+
+    def query(xri, service_types)
+      # these can be query args or http headers, needn't be both.
+      # headers = {'Accept' => 'application/xrds+xml;sep=true'}
+      fetcher = NetHTTPFetcher.new
+      services = service_types.collect { |service_type|
+        url = self.query_url(xri, service_type)
+        response = fetcher.get(url)
+        raise XRIHTTPError, "Could not fetch #{xri}" if response.nil?
+        xrds = XRDS.new(response[1].body)
+        return xrds.services unless xrds.nil?
+      }
+      # TODO:
+      #  * If we do get hits for multiple service_types, we're almost 
+      #    certainly going to have duplicated service entries and 
+      #    broken priority ordering.
+      services = services.inject([]) { |flatter, some_services|
+        flatter.concat(some_services) unless some_services.nil?
+      }
+    end
+  end
+
+  def XRI.urlencode(args)
+    a = []
+    args.each do |key, val|
+      a << (CGI::escape(key) + "=" + CGI::escape(val))
+    end
+    a.join("&")
+  end
+
+  def XRI.append_args(url, args)
+    return url if args.length == 0
+    
+    # rstrip question marks
+    rstripped = url.dup
+    while rstripped[-1].chr == '?'
+      rstripped = rstripped[0...rstripped.length-1]
+    end
+    
+    if rstripped.index('?')
+      sep = '&'
+    else
+      sep = '?'
+    end
+    
+    return url + sep + XRI.urlencode(args)
+  end
+
+end
+
+# Example:
+#  r = XRI::ProxyResolver.new('http://proxy.xri.net/')
+#  j = r.query('=keturn', ['xri://+i-service*(+forwarding)*($v*1.0)'])
+#  Stderr.puts("the answer is #{j}")

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/lib/yadis.rb

@@ -4,3 +4,5 @@ require 'yadis/service'
 require 'yadis/parsehtml'
 require 'yadis/fetcher'
 require 'yadis/manager'
+require 'yadis/xri'
+require 'yadis/xrires'

data/lib/yadis.rb~

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

data/test/data/keturn.xrds

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<XRDS ref="xri://=keturn">
+ <XRD xmlns:xrd="xri://$xrd*($v*2.0)">
+  <Query>*keturn</Query>
+  <Status code="100"/>
+  <Expires>2006-05-31T02:45:37.000Z</Expires>
+  <ProviderID>xri://=</ProviderID>
+  <LocalID priority="10">!2397.58EC.8F7D.D097</LocalID>
+  <CanonicalID priority="10">=!2397.58EC.8F7D.D097</CanonicalID>
+  <Service priority="10">
+   <Type/>
+   <Type>xri://+i-service*(+forwarding)*($v*1.0)</Type>
+   <ProviderID>xri://!!1003</ProviderID>
+   <URI priority="10">https://forwarding.godaddy.amsoftsystems.com</URI>
+  </Service>
+  <Service priority="10">
+   <Type>xri://+i-service*(+contact)*($v*1.0)</Type>
+   <ProviderID>xri://!!1003</ProviderID>
+   <Path>+contact</Path>
+   <MediaType/>
+   <MediaType>text/html</MediaType>
+   <URI priority="10">https://contact.godaddy.amsoftsystems.com</URI>
+  </Service>
+  <Service priority="10">
+   <Type>xri://+i-service*(+authn)*(+saml)*($v*1.0)</Type>
+   <ProviderID>xri://!!1003</ProviderID>
+   <Path>+login</Path>
+   <URI priority="10">https://isso.godaddy.amsoftsystems.com</URI>
+  </Service>
+ </XRD>
+</XRDS>
+

data/test/test_xri.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+require 'yadis/xri'
+
+class XriDiscoveryTestCase < Test::Unit::TestCase
+  
+  def test_isXRI?
+    assert_equal(:xri, XRI.identifier_scheme('=john.smith'))
+    assert_equal(:xri, XRI.identifier_scheme('@smiths/john'))
+    assert_equal(:xri, XRI.identifier_scheme('xri://=john'))
+    assert_equal(:xri, XRI.identifier_scheme('@ootao*test1'))
+    assert_equal(:uri, XRI.identifier_scheme('smoker.myopenid.com'))
+    assert_equal(:uri, XRI.identifier_scheme('http://smoker.myopenid.com'))
+    assert_equal(:uri, XRI.identifier_scheme('https://smoker.myopenid.com'))
+  end
+end
+
+class XriEscapingTestCase < Test::Unit::TestCase
+  def test_escaping_percents
+    assert_equal('@example/abc%252Fd/ef', 
+                 XRI.escape_for_iri('@example/abc%2Fd/ef'))
+  end
+
+  def test_escaping_xref
+    # no escapes
+    assert_equal('@example/foo/(@bar)',
+                 XRI.escape_for_iri('@example/foo/(@bar)'))
+    # escape slashes
+    assert_equal('@example/foo/(@bar%2Fbaz)',
+                 XRI.escape_for_iri('@example/foo/(@bar/baz)'))
+    # escape query ? and fragment #
+    assert_equal('@example/foo/(@baz%3Fp=q%23r)?i=j#k',
+                 XRI.escape_for_iri('@example/foo/(@baz?p=q#r)?i=j#k'))
+  end
+end
+
+class XriTransformationTestCase < Test::Unit::TestCase
+  def test_to_iri_normal
+    assert_equal('xri://@example', XRI.to_iri_normal('@example'))
+  end
+# iri_to_url:
+#   various ucschar to hex
+end
+
+H = 'http://xri.example.com/'
+# ST = 'http://openid.net/signon/1.2'
+ST = 'xri://+i-service*(+forwarding)*($v*1.0)'
+class ProxyQueryTestCase < Test::Unit::TestCase
+  def setup
+    @proxy = XRI::ProxyResolver.new(H)
+  end
+
+  def test_proxy_url
+    args_esc = "_xrd_r=application%2Fxrds%2Bxml&_xrd_t=#{CGI::escape(ST)}"
+    self.assert_equal(H + '=foo?' + args_esc, @proxy.query_url('=foo', ST))
+    self.assert_equal(H + '=foo/bar?baz&' + args_esc, 
+                      @proxy.query_url('=foo/bar?baz', ST))
+    self.assert_equal(H + '=foo/bar?baz=quux&' + args_esc, 
+                      @proxy.query_url('=foo/bar?baz=quux', ST))
+    self.assert_equal(H + '=foo/bar?mi=fa&so=la&' + args_esc, 
+                      @proxy.query_url('=foo/bar?mi=fa&so=la', ST))
+# TODO:
+#     self.assert_equal(H + '=foo/bar??' + args_esc, 
+#                       @proxy.query_url('=foo/bar?', ST))
+#     self.assert_equal(H + '=foo/bar????' + args_esc, 
+#                       @proxy.query_url('=foo/bar???', ST))
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby-yadis
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2006-06-26 00:00:00 -07:00
+  version: 0.3.3
+date: 2006-08-20 00:00:00 -07:00
 summary: A library for performing Yadis service discovery
 require_paths: 
 - lib
@@ -31,29 +31,39 @@ 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~
+- lib/yadis/xri.rb
+- lib/yadis/xrires.rb
 - test/test_parse.rb
 - test/data
 - test/test_discovery.rb
 - test/test_yadis.rb
 - test/test_xrds.rb
 - test/runtests.rb
+- test/test_xri.rb
 - test/data/manifest.txt
 - test/data/brian.xrds
-- test/data/brian_priority.xrds
-- test/data/brian.multi.xrds
 - test/data/index.html
+- test/data/brian.multi.xrds
+- test/data/brian_priority.xrds
 - test/data/brian.multi_uri.xrds
-- test/data/index_yadis.html
 - test/data/index_xrds.html
+- test/data/index_yadis.html
 - test/data/proxy-june1.xrds
 - test/data/weirdver.xrds
+- test/data/keturn.xrds
 - test/data/brianellin.mylid.xrds
 - README
 - INSTALL