ruby-yadis 0.2

data/COPYING

@@ -0,0 +1,10 @@
+Copyright (c) 2006, JanRain, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the JanRain, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/INSTALL

@@ -0,0 +1,22 @@
+= Ruby YADIS Library Installation
+
+== Installation
+
+Unpack the archive and run setup.rb (you may need to be root)
+
+ ruby setup.rb
+
+setup.rb installs the library into your system ruby.  If don't want to
+add yadis to you system ruby, make sure to add the *lib* directory of
+the extracted tarball to your RUBYLIB environment variable.
+
+Make sure everything installed ok:
+ $> irb
+ irb(main):001:0> require "yadis"
+ => true
+
+== Run the test suite
+
+Go into the test directory and execute the *runtests* script.
+
+

data/README

@@ -0,0 +1,22 @@
+=Ruby Yadis
+
+A Ruby library for performing Yadis service discovery.
+
+Yadis Specification details:
+
+* http://yadis.org
+* http://www.openidenabled.com/yadis/yadis-notes/
+
+Please see the INSTALL, and have a look at the YADIS interface in yadis/yadis.rb
+
+==Authors
+Brian Ellin.  brian -at- janrain -dot- com
+JanRain, Inc.  http://www.janrain.com/
+
+Eugene Eric Kim.  eekim -at- blueoxen -dot- com
+Blue Oxen Associates.  http://www.blueoxen.com/
+
+
+
+
+

data/examples/openid.rb

@@ -0,0 +1,18 @@
+# example of finding an OpenID server using YADIS
+
+require 'yadis'
+
+yadis = YADIS.discover('http://brian.myopenid.com/')
+if yadis.nil? or yadis.openid_servers.length == 0
+  p 'No XRDS found'
+else
+  servers = yadis.openid_servers
+  if servers.length == 0
+    p 'No OpenID servers found'
+  else
+    servers.each do |s|
+      p "OpenID server found: #{s.type}, #{s.uri}"
+    end
+  end
+end
+

data/lib/yadis/fetcher.rb

@@ -0,0 +1,72 @@
+require "uri"
+
+begin
+  require "net/https"
+rescue LoadError # no openssl
+  require "net/http" 
+  HAS_OPENSSL = false
+  STDERR.puts("No openssl found, won't be able to fetch https URIs.")
+else
+  HAS_OPENSSL = true
+end
+
+class NetHTTPFetcher
+    
+  def initialize(read_timeout=20, open_timeout=20)
+    @read_timeout = read_timeout
+    @open_timeout = open_timeout
+  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
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        else
+          STDERR.puts("Cannot fetch https url without openssl installed: #{uri.to_s}")
+        end
+      end
+
+      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
+            nil
+        end
+      end
+    end
+
+end

data/lib/yadis/htmltokenizer.rb

@@ -0,0 +1,355 @@
+# = HTMLTokenizer
+#
+# Author::    Ben Giddings  (mailto:bg-rubyforge@infofiend.com)
+# Copyright:: Copyright (c) 2004 Ben Giddings
+# License::   Distributes under the same terms as Ruby
+#
+#
+# This is a partial port of the functionality behind Perl's TokeParser
+# Provided a page it progressively returns tokens from that page
+#
+# $Id: htmltokenizer.rb,v 1.7 2005/06/07 21:05:53 merc Exp $
+
+#
+# A class to tokenize HTML.
+#
+# Example:
+#
+#   page = "<HTML>
+#   <HEAD>
+#   <TITLE>This is the title</TITLE>
+#   </HEAD>
+#    <!-- Here comes the <a href=\"missing.link\">blah</a>
+#    comment body
+#     -->
+#    <BODY>
+#      <H1>This is the header</H1>
+#      <P>
+#        This is the paragraph, it contains
+#        <a href=\"link.html\">links</a>,
+#        <img src=\"blah.gif\" optional alt='images
+#        are
+#        really cool'>.  Ok, here is some more text and
+#        <A href=\"http://another.link.com/\" target=\"_blank\">another link</A>.
+#      </P>
+#    </body>
+#    </HTML>
+#    "
+#    toke = HTMLTokenizer.new(page)
+#
+#    assert("<h1>" == toke.getTag("h1", "h2", "h3").to_s.downcase)
+#    assert(HTMLTag.new("<a href=\"link.html\">") == toke.getTag("IMG", "A"))
+#    assert("links" == toke.getTrimmedText)
+#    assert(toke.getTag("IMG", "A").attr_hash['optional'])
+#    assert("_blank" == toke.getTag("IMG", "A").attr_hash['target'])
+#
+class HTMLTokenizer
+  @@version = 1.0
+
+  # Get version of HTMLTokenizer lib
+  def self.version
+    @@version
+  end
+
+  attr_reader :page
+
+  # Create a new tokenizer, based on the content, used as a string.
+  def initialize(content)
+    @page = content.to_s
+    @cur_pos = 0
+  end
+
+  # Reset the parser, setting the current position back at the stop
+  def reset
+    @cur_pos = 0
+  end
+
+  # Look at the next token, but don't actually grab it
+  def peekNextToken
+    if @cur_pos == @page.length then return nil end
+
+    if ?< == @page[@cur_pos]
+      # Next token is a tag of some kind
+      if '!--' == @page[(@cur_pos + 1), 3]
+        # Token is a comment
+        tag_end = @page.index('-->', (@cur_pos + 1))
+        if tag_end.nil?
+          raise "No end found to started comment:\n#{@page[@cur_pos,80]}"
+        end
+        # p @page[@cur_pos .. (tag_end+2)]
+        HTMLComment.new(@page[@cur_pos .. (tag_end + 2)])
+      else
+        # Token is a html tag
+        tag_end = @page.index('>', (@cur_pos + 1))
+        if tag_end.nil?
+          raise "No end found to started tag:\n#{@page[@cur_pos,80]}"
+        end
+        # p @page[@cur_pos .. tag_end]
+        HTMLTag.new(@page[@cur_pos .. tag_end])
+      end
+    else
+      # Next token is text
+      text_end = @page.index('<', @cur_pos)
+      text_end = text_end.nil? ? -1 : (text_end - 1)
+      # p @page[@cur_pos .. text_end]
+      HTMLText.new(@page[@cur_pos .. text_end])
+    end
+  end
+
+  # Get the next token, returns an instance of
+  # * HTMLText
+  # * HTMLToken
+  # * HTMLTag
+  def getNextToken
+    token = peekNextToken
+    if token
+      # @page = @page[token.raw.length .. -1]
+      # @page.slice!(0, token.raw.length)
+      @cur_pos += token.raw.length
+    end
+    #p token
+    #print token.raw
+    return token
+  end
+
+  # Get a tag from the specified set of desired tags.
+  # For example:
+  # <tt>foo =  toke.getTag("h1", "h2", "h3")</tt>
+  # Will return the next header tag encountered.
+  def getTag(*sought_tags)
+    sought_tags.collect! {|elm| elm.downcase}
+
+    while (tag = getNextToken)
+      if tag.kind_of?(HTMLTag) and
+          (0 == sought_tags.length or sought_tags.include?(tag.tag_name))
+        break
+      end
+    end
+    tag
+  end
+
+  # Get all the text between the current position and the next tag
+  # (if specified) or a specific later tag
+  def getText(until_tag = nil)
+    if until_tag.nil?
+      if ?< == @page[@cur_pos]
+        # Next token is a tag, not text
+        ""
+      else
+        # Next token is text
+        getNextToken.text
+      end
+    else
+      ret_str = ""
+
+      while (tag = peekNextToken)
+        if tag.kind_of?(HTMLTag) and tag.tag_name == until_tag
+          break
+        end
+
+        if ("" != tag.text)
+          ret_str << (tag.text + " ")
+        end
+        getNextToken
+      end
+
+      ret_str
+    end
+  end
+
+  # Like getText, but squeeze all whitespace, getting rid of
+  # leading and trailing whitespace, and squeezing multiple
+  # spaces into a single space.
+  def getTrimmedText(until_tag = nil)
+    getText(until_tag).strip.gsub(/\s+/m, " ")
+  end
+
+end
+
+# The parent class for all three types of HTML tokens
+class HTMLToken
+  attr_accessor :raw
+
+  # Initialize the token based on the raw text
+  def initialize(text)
+    @raw = text
+  end
+
+  # By default, return exactly the string used to create the text
+  def to_s
+    raw
+  end
+
+  # By default tokens have no text representation
+  def text
+    ""
+  end
+
+  def trimmed_text
+    text.strip.gsub(/\s+/m, " ")
+  end
+
+  # Compare to another based on the raw source
+  def ==(other)
+    raw == other.to_s
+  end
+end
+
+# Class representing text that isn't inside a tag
+class HTMLText < HTMLToken
+  def text
+    raw
+  end
+end
+
+# Class representing an HTML comment
+class HTMLComment < HTMLToken
+  attr_accessor :contents
+  def initialize(text)
+    super(text)
+    temp_arr = text.scan(/^<!--\s*(.*?)\s*-->$/m)
+    if temp_arr[0].nil?
+      raise "Text passed to HTMLComment.initialize is not a comment"
+    end
+
+    @contents = temp_arr[0][0]
+  end
+end
+
+# Class representing an HTML tag
+class HTMLTag < HTMLToken
+  attr_reader :end_tag, :tag_name
+  def initialize(text)
+    super(text)
+    if ?< != text[0] or ?> != text[-1]
+      raise "Text passed to HTMLComment.initialize is not a comment"
+    end
+
+    @attr_hash = Hash.new
+    @raw = text
+
+    tag_name = text.scan(/[\w:-]+/)[0]
+    if tag_name.nil?
+      raise "Error, tag is nil: #{tag_name}"
+    end
+
+    if ?/ == text[1]
+      # It's an end tag
+      @end_tag = true
+      @tag_name = '/' + tag_name.downcase
+    else
+      @end_tag = false
+      @tag_name = tag_name.downcase
+    end
+
+    @hashed = false
+  end
+
+  # Retrieve a hash of all the tag's attributes.
+  # Lazily done, so that if you don't look at a tag's attributes
+  # things go quicker
+  def attr_hash
+    # Lazy initialize == don't build the hash until it's needed
+    if !@hashed
+      if !@end_tag
+        # Get the attributes
+        attr_arr = @raw.scan(/<[\w:-]+\s+(.*)>/m)[0]
+        if attr_arr.kind_of?(Array)
+          # Attributes found, parse them
+          attrs = attr_arr[0]
+          attr_arr = attrs.scan(/\s*([\w:-]+)(?:\s*=\s*("[^"]*"|'[^']*'|([^"'>][^\s>]*)))?/m)
+          # clean up the array by:
+          # * setting all nil elements to true
+          # * removing enclosing quotes
+          attr_arr.each {
+            |item|
+            val = if item[1].nil?
+                    item[0]
+                  elsif '"'[0] == item[1][0] or '\''[0] == item[1][0]
+                    item[1][1 .. -2]
+                  else
+                    item[1]
+                  end
+            @attr_hash[item[0].downcase] = val
+          }
+        end
+      end
+      @hashed = true
+    end
+
+    #p self
+
+    @attr_hash
+  end
+
+  # Get the 'alt' text for a tag, if it exists, or an empty string otherwise
+  def text
+    if !end_tag
+      case tag_name
+      when 'img'
+        if !attr_hash['alt'].nil?
+          return attr_hash['alt']
+        end
+      when 'applet'
+        if !attr_hash['alt'].nil?
+          return attr_hash['alt']
+        end
+      end
+    end
+    return ''
+  end
+end
+
+if $0 == __FILE__
+  require 'test/unit'
+
+  class TC_TestHTMLTokenizer < Test::Unit::TestCase
+    def test_bad_link
+      toke = HTMLTokenizer.new("<p><a href=http://bad.com/link>foo</a></p>")
+      assert("http://bad.com/link" == toke.getTag("a").attr_hash['href'])
+    end
+
+    def test_namespace
+      toke = HTMLTokenizer.new("<f:table xmlns:f=\"http://www.com/foo\">")
+      assert("http://www.com/foo" == toke.getTag("f:table").attr_hash['xmlns:f'])
+    end
+
+    def test_comment
+      toke = HTMLTokenizer.new("<!-- comment on me -->")
+      t = toke.getNextToken
+      assert(HTMLComment == t.class)
+      assert("comment on me" == t.contents)
+    end
+
+
+    def test_full
+      page = "<HTML>
+<HEAD>
+<TITLE>This is the title</TITLE>
+</HEAD>
+<!-- Here comes the <a href=\"missing.link\">blah</a>
+comment body
+ -->
+<BODY>
+  <H1>This is the header</H1>
+  <P>
+    This is the paragraph, it contains
+    <a href=\"link.html\">links</a>, 
+    <img src=\"blah.gif\" optional alt='images
+are
+really cool'>.  Ok, here is some more text and
+    <A href=\"http://another.link.com/\" target=\"_blank\">another link</A>.
+  </P>
+</body>
+</HTML>
+"
+      toke = HTMLTokenizer.new(page)
+
+      assert("<h1>" == toke.getTag("h1", "h2", "h3").to_s.downcase)
+      assert(HTMLTag.new("<a href=\"link.html\">") == toke.getTag("IMG", "A"))
+      assert("links" == toke.getTrimmedText)
+      assert(toke.getTag("IMG", "A").attr_hash['optional'])
+      assert("_blank" == toke.getTag("IMG", "A").attr_hash['target'])
+    end
+  end
+end

data/lib/yadis/parsehtml.rb

@@ -0,0 +1,32 @@
+require "yadis/htmltokenizer"
+
+def html_yadis_location(html)
+  parser = HTMLTokenizer.new(html)
+
+  # to keep track of whether or not we are in the head element
+  in_head = false
+
+  begin
+    while el = parser.getTag('head', '/head', 'meta', 'body')
+      
+      # we are leaving head or have reached body, so we bail
+      return nil if ['/head', 'body'].member?(el.tag_name)
+
+      # meta needs to be in head, so we mark it
+      in_head = true if el.tag_name == 'head'
+      continue unless in_head
+
+      if el.tag_name == 'meta' and (equiv = el.attr_hash['http-equiv'])
+        if ['x-xrds-location','x-yadis-location'].member?(equiv.downcase)
+          return el.attr_hash['content']
+        end
+      end
+      
+    end
+  rescue
+    return nil
+  end
+
+end
+
+

data/lib/yadis/xrds.rb

@@ -0,0 +1,145 @@
+require 'rexml/document'
+
+# Class that handles XRDS parsing and XRD Service element extraction.
+class XRDS
+
+  # 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
+
+  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)
+    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 parse_xml(xml_text)   
+    begin
+      xml = REXML::Document.new(xml_text)
+    rescue
+      raise ArgumentError, "Can't parse XRDS"
+    end
+    
+    if xml.root.nil?
+      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"
+    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
+  end
+
+  # Returns an Array of Service objects, sorted by priority.  Highest
+  # priority is at element 0.
+  def services
+    s = []
+
+    @services.keys.sort.each do |key| @services[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
+
+  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)
+
+      elsif uri_element.attributes['priority']
+        priority = uri_element.attributes['priority'].to_i
+        _add_service(priority, service)
+
+      else
+        _add_service(priority_index, service)
+        priority_index -= 1
+      end
+
+    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_other(name, value)
+    @other[name] = value
+  end
+
+  def other
+    return @other
+  end
+end

data/lib/yadis/yadis.rb

@@ -0,0 +1,98 @@
+require 'yadis/xrds'
+require 'yadis/fetcher'
+require 'yadis/parsehtml'
+
+class YADISParseError < StandardError; end
+class YADISHTTPError < StandardError; end
+
+class YADIS
+  
+  attr_reader :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.
+  #
+  # Returns nil if no XRDS was found, or a YADIS object on success.
+  def YADIS.discover(uri)
+    begin
+      return YADIS.discover_verbose(uri)
+    rescue
+      return nil
+    end
+  end
+
+  # same as YADIS.discover, but raises YADISParseError or YADISHTTPError
+  # when bad things happen.
+  def YADIS.discover_verbose(uri)
+    return nil unless uri
+
+    headers = {'Accept' => 'application/xrds+xml'}
+    response = NetHTTPFetcher.new.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 = NetHTTPFetcher.new.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 = NetHTTPFetcher.new.get(loc)
+      end
+    end
+
+    xrds = XRDS.parse(resp_payload.body)
+    raise YADISParseError, "Bad XRDS" if xrds.nil?
+
+    return new(uri, xrds_uri, xrds)
+  end
+
+  def initialize(uri, xrds_uri, xrds)
+    @uri = uri
+    @xrds_uri = xrds_uri
+    @xrds = xrds
+  end
+
+  # Returns an Array Service objects sorted by priority.
+  def services
+    @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
+    
+    return @xrds.services.find_all {|s| s.service_type.match(base_url)}
+  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.rb

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

data/test/data/brian.multi.xrds

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xrds:XRDS
+    xmlns:xrds="xri://$xrds"
+    xmlns:openid="http://openid.net/xmlns/1.0"
+    xmlns="xri://$xrd*($v*2.0)">
+  <XRD>
+
+    <Service priority="2">
+      <Type>http://openid.net/signon/1.1</Type>
+      <URI>http://www.myopenid.com/server</URI>
+      <openid:Delegate>http://frank.myopenid.com/</openid:Delegate>
+    </Service>
+
+  </XRD>
+  <XRD>
+
+    <Service priority="1">
+      <Type>http://bar.com/</Type>
+      <URI>http://bar.com/server</URI>
+    </Service>
+
+    <Service priority="2">
+      <Type>http://foo.com</Type>
+      <URI>http://foo.com/server</URI>
+    </Service>
+
+  </XRD>
+  <XRD>
+
+    <Service priority="0">
+      <Type>http://openid.net/signon/1.0</Type>
+      <URI>http://www.myopenid.com/server</URI>
+      <openid:Delegate>http://brian.myopenid.com/</openid:Delegate>
+    </Service>
+
+  </XRD>
+</xrds:XRDS>
+

data/test/data/brian.multi_uri.xrds

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xrds:XRDS
+    xmlns:xrds="xri://$xrds"
+    xmlns:openid="http://openid.net/xmlns/1.0"
+    xmlns="xri://$xrd*($v*2.0)">
+  <XRD>
+
+    <Service>
+      <Type>http://openid.net/signon/1.0</Type>
+      <URI>http://www.myopenid.com/server</URI>
+      <URI>http://example.com/server</URI>
+    </Service>
+
+  </XRD>
+</xrds:XRDS>
+

data/test/data/brian.xrds

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xrds:XRDS
+    xmlns:xrds="xri://$xrds"
+    xmlns:openid="http://openid.net/xmlns/1.0"
+    xmlns="xri://$xrd*($v*2.0)">
+  <XRD>
+
+    <Service priority="0">
+      <Type>http://openid.net/signon/1.0</Type>
+      <URI>http://www.myopenid.com/server</URI>
+      <openid:Delegate>http://brian.myopenid.com/</openid:Delegate>
+    </Service>
+
+  </XRD>
+</xrds:XRDS>
+

data/test/data/brian_priority.xrds

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xrds:XRDS
+    xmlns:xrds="xri://$xrds"
+    xmlns:openid="http://openid.net/xmlns/1.0"
+    xmlns="xri://$xrd*($v*2.0)">
+  <XRD>
+
+    <Service priority="2">
+      <Type>http://openid.net/signon/1.0</Type>
+      <URI>http://www.schtuff.com/?action=openid_server</URI>
+      <openid:Delegate>http://users.schtuff.com/brian</openid:Delegate>
+    </Service>
+
+    <Service priority="1">
+      <Type>http://openid.net/signon/1.0</Type>
+      <URI>http://www.myopenid.com/server</URI>
+      <openid:Delegate>http://brian.myopenid.com/</openid:Delegate>
+    </Service>
+
+  </XRD>
+</xrds:XRDS>
+

data/test/data/index.html

@@ -0,0 +1,29 @@
+<html>
+
+  <head>
+
+    <meta http-equiv="X-XRDS-Location" content="http://brian.myopenid.com/xrds" />
+    <meta http-equiv="X-YADIS-Location" content="http://brian.myopenid.com/xrds" />
+	
+    <link rel="openid.server" href="http://www.myopenid.com/server" />
+    <link rel="openid.delegate" href="http://brian.myopenid.com/" />
+
+    <title>Foo</title>
+    <style type="text/css">
+      * {font-family: sans-serif; color: #555; font-size: 1em;}
+      body {background-color: #eee;}
+      a {color: #555;}
+      img {border:2px solid #bbb;}
+      #main {text-align:center; margin-top:4em;}
+      #menu {}
+    </style>
+
+  </head>
+
+  <body>
+    <div id="main">
+      stuff
+    </div>
+  </body>
+
+</html>

data/test/data/index_xrds.html

@@ -0,0 +1,25 @@
+<html>
+
+  <head>
+
+    <meta http-equiv="X-XRDS-Location" content="http://brian.myopenid.com/xrds" />
+
+    <title>Foo</title>
+    <style type="text/css">
+      * {font-family: sans-serif; color: #555; font-size: 1em;}
+      body {background-color: #eee;}
+      a {color: #555;}
+      img {border:2px solid #bbb;}
+      #main {text-align:center; margin-top:4em;}
+      #menu {}
+    </style>
+
+  </head>
+
+  <body>
+    <div id="main">
+      stuff
+    </div>
+  </body>
+
+</html>

data/test/data/index_yadis.html

@@ -0,0 +1,26 @@
+<html>
+
+  <head>
+
+    <meta http-equiv="X-YADIS-Location" content="http://brian.myopenid.com/xrds" />
+	
+
+    <title>Foo</title>
+    <style type="text/css">
+      * {font-family: sans-serif; color: #555; font-size: 1em;}
+      body {background-color: #eee;}
+      a {color: #555;}
+      img {border:2px solid #bbb;}
+      #main {text-align:center; margin-top:4em;}
+      #menu {}
+    </style>
+
+  </head>
+
+  <body>
+    <div id="main">
+      stuff
+    </div>
+  </body>
+
+</html>

data/test/data/manifest.txt

@@ -0,0 +1,30 @@
+# This file contains test cases for doing YADIS identity URL and
+# service discovery. For each case, there are three URLs. The first
+# URL is the user input. The second is the identity URL and the third
+# is the URL from which the XRDS document should be read.
+#
+# The file format is as follows:
+# User URL <tab> Identity URL <tab> XRDS URL <newline>
+#
+# blank lines and lines starting with # should be ignored.
+#
+# To use this test:
+#
+# 1. Run your discovery routine on the User URL.
+#
+# 2. Compare the identity URL returned by the discovery routine to the
+#    identity URL on that line of the file. It must be an EXACT match.
+#
+# 3. Do a regular HTTP GET on the XRDS URL. Compare the content that
+#    was returned by your discovery routine with the content returned
+#    from that URL. It should also be an exact match.
+
+http://www.openidenabled.com/resources/yadis-test/discover/equiv	http://www.openidenabled.com/resources/yadis-test/discover/equiv	http://www.openidenabled.com/resources/yadis-test/discover/xrds
+http://www.openidenabled.com/resources/yadis-test/discover/header	http://www.openidenabled.com/resources/yadis-test/discover/header	http://www.openidenabled.com/resources/yadis-test/discover/xrds
+http://www.openidenabled.com/resources/yadis-test/discover/xrds	http://www.openidenabled.com/resources/yadis-test/discover/xrds	http://www.openidenabled.com/resources/yadis-test/discover/xrds
+http://www.openidenabled.com/resources/yadis-test/discover/xrds_html	http://www.openidenabled.com/resources/yadis-test/discover/xrds_html	http://www.openidenabled.com/resources/yadis-test/discover/xrds_html
+http://www.openidenabled.com/resources/yadis-test/discover/redir_equiv	http://www.openidenabled.com/resources/yadis-test/discover/equiv	http://www.openidenabled.com/resources/yadis-test/discover/xrds
+http://www.openidenabled.com/resources/yadis-test/discover/redir_header	http://www.openidenabled.com/resources/yadis-test/discover/header	http://www.openidenabled.com/resources/yadis-test/discover/xrds
+http://www.openidenabled.com/resources/yadis-test/discover/redir_xrds	http://www.openidenabled.com/resources/yadis-test/discover/xrds	http://www.openidenabled.com/resources/yadis-test/discover/xrds
+http://www.openidenabled.com/resources/yadis-test/discover/redir_xrds_html	http://www.openidenabled.com/resources/yadis-test/discover/xrds_html	http://www.openidenabled.com/resources/yadis-test/discover/xrds_html
+http://www.openidenabled.com/resources/yadis-test/discover/redir_redir_equiv	http://www.openidenabled.com/resources/yadis-test/discover/equiv	http://www.openidenabled.com/resources/yadis-test/discover/xrds

data/test/runtests.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'test_discovery'
+require 'test_parse'
+require 'test_xrds'
+require 'test_yadis'
+

data/test/test_discovery.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'yadis'
+
+# run all the discovery tests from
+# http://www.openidenabled.com/resources/yadis-test/discover/manifest.txt
+# a local copy of the test data is in data/manifest.txt
+
+class DiscoveryTestCase < Test::Unit::TestCase
+
+  def setup
+    @cases = []
+    File.open('data/manifest.txt').each_line do |line|
+      line.strip!
+      if line.index('#') != 0 and line
+        @cases << line.split(' ', 3) if line.length > 0
+      end
+    end
+
+  end
+
+  def test_discovery
+    @cases.each_with_index do |x, i|
+      input, redir_uri, xrds_uri = x
+      y = YADIS.discover(input)
+      assert_not_nil(y)
+      assert_equal(redir_uri, y.uri)
+      assert_equal(xrds_uri, y.xrds_uri)
+    end
+  end
+
+  def test_bad
+    assert_nil(YADIS.discover(nil))
+    assert_nil(YADIS.discover(5))
+
+    # not a valid uri
+    assert_nil(YADIS.discover('foo.com'))
+
+    # not a yadis uri
+    assert_nil(YADIS.discover('http://google.com/?q=huh'))
+  end
+
+end

data/test/test_parse.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'yadis/parsehtml'
+
+class YadisHTMLParseTestCase < Test::Unit::TestCase
+
+  def check(x, html)
+    result = html_yadis_location(html)
+    assert_equal(x, result)
+  end
+
+  def test_valid
+    check('foo', '<html><head><meta http-equiv="X-YADIS-LOCATION" content="foo"/></head></html>')
+    
+    check('foo', '<html><head><meta http-equiv="X-YADIS-LOCATION" content="foo"/></head></html>')
+    check('foo', '<html><head><meta http-equiv="X-YADIS-LOCATION" content="foo"/></head></html>')
+    check('foo', '<html><head><meta HTTP-EQUIV="X-YADIS-LOCATION" CONTENT="foo"/></head></html>')
+    check('foo', '<html><head><meta HTTP-EQUIV="X-YADIS-Location" CONTENT="foo"/></head></html>')
+    check('http://brian.myopenid.com/xrds', File.open('data/index.html').read)
+    check('http://brian.myopenid.com/xrds', File.open('data/index_xrds.html').read)
+    check('http://brian.myopenid.com/xrds', File.open('data/index_yadis.html').read)
+  end
+
+  def test_fail
+    check(nil, '')
+    check(nil, nil)
+    check(nil, 5)
+    check(nil, '<html></html>')
+
+    # no content attr
+    check(nil, '<html><head><meta http-equiv="x-yadis-location" /><meta http-equiv="X-YADIS-LOCATION" content="foo"/></head></html>')
+
+    # not in head
+    check(nil, '<html><meta http-equiv="X-YADIS-LOCATION" content="foo"/></html>')
+    check(nil, '<html><body><meta http-equiv="X-YADIS-LOCATION" content="foo"/></html>')
+  end
+
+end

data/test/test_xrds.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'yadis/xrds'
+
+class XRDSTestCase < Test::Unit::TestCase
+
+  def test_xrds_good
+    File.open('data/brian.xrds') do |f|
+      xrds = XRDS.parse(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)
+      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)
+    end
+  end
+
+  def test_xrds_good_uri_multi
+    File.open('data/brian.multi_uri.xrds') do |f|
+      xrds = XRDS.parse(f.read)
+      assert_not_nil(xrds)
+      assert_equal(2, xrds.services.length)
+    end
+  end
+
+  def test_xrds_bad
+    assert_nil(XRDS.parse(nil))
+    assert_nil(XRDS.parse(5))
+    assert_nil(XRDS.parse(''))
+    assert_nil(XRDS.parse('<html></html>'))
+    assert_nil(XRDS.parse('\000'))
+  end
+
+end

data/test/test_yadis.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+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, 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
+
+  def test_priority
+    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)
+
+  end
+
+
+end

metadata

@@ -0,0 +1,72 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: ruby-yadis
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+date: 2006-03-16 00:00:00 -08:00
+summary: A library for performing Yadis service discovery
+require_paths: 
+- lib
+email: brian@janrian.com, eekim@blueoxen.com
+homepage: http://www.openidenabled.com/yadis/libraries/ruby
+rubyforge_project: 
+description: 
+autorequire: yadis
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Brian Ellin (JanRain, Inc), Eugene Eric Kim (Blue Oxen Associates)
+files: 
+- examples/openid.rb
+- lib/yadis.rb
+- lib/yadis
+- lib/yadis/parsehtml.rb
+- lib/yadis/xrds.rb
+- lib/yadis/yadis.rb
+- lib/yadis/fetcher.rb
+- lib/yadis/htmltokenizer.rb
+- test/test_parse.rb
+- test/data
+- test/test_discovery.rb
+- test/test_yadis.rb
+- test/test_xrds.rb
+- test/runtests.rb
+- test/data/manifest.txt
+- test/data/brian.xrds
+- test/data/index.html
+- test/data/brian.multi.xrds
+- test/data/brian_priority.xrds
+- test/data/brian.multi_uri.xrds
+- test/data/index_xrds.html
+- test/data/index_yadis.html
+- README
+- INSTALL
+- COPYING
+test_files: 
+- test/runtests.rb
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+- INSTALL
+- COPYING
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+