ruby-openid 1.1.4 → 2.0.1

data/lib/openid/yadis/filters.rb

@@ -0,0 +1,205 @@
+# This file contains functions and classes used for extracting
+# endpoint information out of a Yadis XRD file using the REXML
+# XML parser.
+
+#
+module OpenID
+  module Yadis
+    class BasicServiceEndpoint
+      attr_reader :type_uris, :yadis_url, :uri, :service_element
+
+      # Generic endpoint object that contains parsed service
+      # information, as well as a reference to the service element
+      # from which it was generated. If there is more than one
+      # xrd:Type or xrd:URI in the xrd:Service, this object represents
+      # just one of those pairs.
+      #
+      # This object can be used as a filter, because it implements
+      # fromBasicServiceEndpoint.
+      #
+      # The simplest kind of filter you can write implements
+      # fromBasicServiceEndpoint, which takes one of these objects.
+      def initialize(yadis_url, type_uris, uri, service_element)
+        @type_uris = type_uris
+        @yadis_url = yadis_url
+        @uri = uri
+        @service_element = service_element
+      end
+
+      # Query this endpoint to see if it has any of the given type
+      # URIs. This is useful for implementing other endpoint classes
+      # that e.g. need to check for the presence of multiple
+      # versions of a single protocol.
+      def match_types(type_uris)
+        return @type_uris & type_uris
+      end
+
+      # Trivial transform from a basic endpoint to itself. This
+      # method exists to allow BasicServiceEndpoint to be used as a
+      # filter.
+      #
+      # If you are subclassing this object, re-implement this function.
+      def self.from_basic_service_endpoint(endpoint)
+        return endpoint
+      end
+
+      # A hack to make both this class and its instances respond to
+      # this message since Ruby doesn't support static methods.
+      def from_basic_service_endpoint(endpoint)
+        return self.class.from_basic_service_endpoint(endpoint)
+      end
+
+    end
+
+    # Take a list of basic filters and makes a filter that
+    # transforms the basic filter into a top-level filter. This is
+    # mostly useful for the implementation of make_filter, which
+    # should only be needed for special cases or internal use by
+    # this library.
+    #
+    # This object is useful for creating simple filters for services
+    # that use one URI and are specified by one Type (we expect most
+    # Types will fit this paradigm).
+    #
+    # Creates a BasicServiceEndpoint object and apply the filter
+    # functions to it until one of them returns a value.
+    class TransformFilterMaker
+      attr_reader :filter_procs
+
+      # Initialize the filter maker's state
+      #
+      # filter_functions are the endpoint transformer
+      # Procs to apply to the basic endpoint. These are called in
+      # turn until one of them does not return nil, and the result
+      # of that transformer is returned.
+      def initialize(filter_procs)
+        @filter_procs = filter_procs
+      end
+
+      # Returns an array of endpoint objects produced by the
+      # filter procs.
+      def get_service_endpoints(yadis_url, service_element)
+        endpoints = []
+
+        # Do an expansion of the service element by xrd:Type and
+        # xrd:URI
+        Yadis::expand_service(service_element).each { |type_uris, uri, _|
+          # Create a basic endpoint object to represent this
+          # yadis_url, Service, Type, URI combination
+          endpoint = BasicServiceEndpoint.new(
+                yadis_url, type_uris, uri, service_element)
+
+          e = apply_filters(endpoint)
+          if !e.nil?
+            endpoints << e
+          end
+        }
+        return endpoints
+      end
+
+      def apply_filters(endpoint)
+        # Apply filter procs to an endpoint until one of them returns
+        # non-nil.
+        @filter_procs.each { |filter_proc|
+          e = filter_proc.call(endpoint)
+          if !e.nil?
+            # Once one of the filters has returned an endpoint, do not
+            # apply any more.
+            return e
+          end
+        }
+
+        return nil
+      end
+    end
+
+    class CompoundFilter
+      attr_reader :subfilters
+
+      # Create a new filter that applies a set of filters to an
+      # endpoint and collects their results.
+      def initialize(subfilters)
+        @subfilters = subfilters
+      end
+
+      # Generate all endpoint objects for all of the subfilters of
+      # this filter and return their concatenation.
+      def get_service_endpoints(yadis_url, service_element)
+        endpoints = []
+        @subfilters.each { |subfilter|
+          endpoints += subfilter.get_service_endpoints(yadis_url, service_element)
+        }
+        return endpoints
+      end
+    end
+
+    # Exception raised when something is not able to be turned into a
+    # filter
+    @@filter_type_error = TypeError.new(
+      'Expected a filter, an endpoint, a callable or a list of any of these.')
+
+    # Convert a filter-convertable thing into a filter
+    #
+    # parts should be a filter, an endpoint, a callable, or a list of
+    # any of these.
+    def self.make_filter(parts)
+      # Convert the parts into a list, and pass to mk_compound_filter
+      if parts.nil?
+        parts = [BasicServiceEndpoint]
+      end
+
+      if parts.is_a?(Array)
+        return mk_compound_filter(parts)
+      else
+        return mk_compound_filter([parts])
+      end
+    end
+
+    # Create a filter out of a list of filter-like things
+    #
+    # Used by make_filter
+    #
+    # parts should be a list of things that can be passed to make_filter
+    def self.mk_compound_filter(parts)
+
+      if !parts.respond_to?('each')
+        raise TypeError, "#{parts.inspect} is not iterable"
+      end
+
+      # Separate into a list of callables and a list of filter objects
+      transformers = []
+      filters = []
+      parts.each { |subfilter|
+        if !subfilter.is_a?(Array)
+          # If it's not an iterable
+          if subfilter.respond_to?('get_service_endpoints')
+            # It's a full filter
+            filters << subfilter
+          elsif subfilter.respond_to?('from_basic_service_endpoint')
+            # It's an endpoint object, so put its endpoint conversion
+            # attribute into the list of endpoint transformers
+            transformers << subfilter.method('from_basic_service_endpoint')
+          elsif subfilter.respond_to?('call')
+            # It's a proc, so add it to the list of endpoint
+            # transformers
+            transformers << subfilter
+          else
+            raise @@filter_type_error
+          end
+        else
+          filters << mk_compound_filter(subfilter)
+        end
+      }
+
+      if transformers.length > 0
+        filters << TransformFilterMaker.new(transformers)
+      end
+
+      if filters.length == 1
+        return filters[0]
+      else
+        return CompoundFilter.new(filters)
+      end
+    end
+  end
+end

data/lib/openid/{htmltokenizer.rb → yadis/htmltokenizer.rb}

@@ -253,7 +253,7 @@ class HTMLTag < HTMLToken
     if !@hashed
       if !@end_tag
         # Get the attributes
-        attr_arr = @raw.scan(/<[\w:-]+\s+(.*)>/m)[0]
+        attr_arr = @raw.scan(/<[\w:-]+\s+(.*?)\/?>/m)[0]
         if attr_arr.kind_of?(Array)
           # Attributes found, parse them
           attrs = attr_arr[0]
@@ -300,56 +300,3 @@ class HTMLTag < HTMLToken
   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/openid/yadis/parsehtml.rb

@@ -0,0 +1,36 @@
+require "openid/yadis/htmltokenizer"
+require 'cgi'
+
+module OpenID
+  module Yadis
+    def Yadis.html_yadis_location(html)
+      parser = HTMLTokenizer.new(html)
+
+      # to keep track of whether or not we are in the head element
+      in_head = false
+
+      while el = parser.getTag('head', '/head', 'meta', 'body', '/body', 'html')
+
+        # we are leaving head or have reached body, so we bail
+        return nil if ['/head', 'body', '/body'].member?(el.tag_name)
+
+        if el.tag_name == 'head'
+          unless el.to_s[-2] == 47 # tag ends with a /: a short tag
+            in_head = true
+          end
+        end
+        next unless in_head
+
+        return nil if el.tag_name == 'html'
+
+        if el.tag_name == 'meta' and (equiv = el.attr_hash['http-equiv'])
+          if ['x-xrds-location','x-yadis-location'].member?(equiv.downcase)
+            return CGI::unescapeHTML(el.attr_hash['content'])
+          end
+        end
+      
+      end
+    end
+  end
+end
+

data/lib/openid/yadis/services.rb

@@ -0,0 +1,42 @@
+
+require 'openid/yadis/filters'
+require 'openid/yadis/discovery'
+require 'openid/yadis/xrds'
+
+module OpenID
+  module Yadis
+    def Yadis.get_service_endpoints(input_url, flt=nil)
+      # Perform the Yadis protocol on the input URL and return an
+      # iterable of resulting endpoint objects.
+      #
+      # @param flt: A filter object or something that is convertable
+      # to a filter object (using mkFilter) that will be used to
+      # generate endpoint objects. This defaults to generating
+      # BasicEndpoint objects.
+      result = Yadis.discover(input_url)
+      begin
+        endpoints = Yadis.apply_filter(result.normalized_uri,
+                                       result.response_text, flt)
+      rescue XRDSError => err
+        raise DiscoveryFailure.new(err.to_s, nil)
+      end
+
+      return [result.normalized_uri, endpoints]
+    end
+
+    def Yadis.apply_filter(normalized_uri, xrd_data, flt=nil)
+      # Generate an iterable of endpoint objects given this input data,
+      # presumably from the result of performing the Yadis protocol.
+
+      flt = Yadis.make_filter(flt)
+      et = Yadis.parseXRDS(xrd_data)
+
+      endpoints = []
+      each_service(et) { |service_element|
+        endpoints += flt.get_service_endpoints(normalized_uri, service_element)
+      }
+
+      return endpoints
+    end
+  end
+end

data/lib/openid/yadis/xrds.rb

@@ -0,0 +1,171 @@
+require 'rexml/document'
+require 'rexml/element'
+require 'rexml/xpath'
+
+module OpenID
+  module Yadis
+
+    XRD_NS_2_0 = 'xri://$xrd*($v*2.0)'
+    XRDS_NS = 'xri://$xrds'
+
+    XRDS_NAMESPACES = {
+      'xrds' => XRDS_NS,
+      'xrd' => XRD_NS_2_0,
+    }
+
+    class XRDSError < StandardError; end
+
+    # Raised when there's an assertion in the XRDS that it does not
+    # have the authority to make.
+    class XRDSFraud < XRDSError
+    end
+
+    def Yadis::get_canonical_id(iname, xrd_tree)
+      # Return the CanonicalID from this XRDS document.
+      #
+      # @param iname: the XRI being resolved.
+      # @type iname: unicode
+      #
+      # @param xrd_tree: The XRDS output from the resolver.
+      #
+      # @returns: The XRI CanonicalID or None.
+      # @returntype: unicode or None
+
+      xrd_list = []
+      REXML::XPath::match(xrd_tree.root, '/xrds:XRDS/xrd:XRD', XRDS_NAMESPACES).each { |el|
+        xrd_list << el
+      }
+
+      xrd_list.reverse!
+
+      cid_elements = []
+
+      if !xrd_list.empty?
+        xrd_list[0].elements.each { |e|
+          if !e.respond_to?('name')
+            next
+          end
+          if e.name == 'CanonicalID'
+            cid_elements << e
+          end
+        }
+      end
+
+      cid_element = cid_elements[-1]
+
+      if !cid_element
+        return nil
+      end
+
+      canonicalID = XRI.make_xri(cid_element.text)
+
+      childID = canonicalID
+
+      xrd_list[1..-1].each { |xrd|
+        parent_sought = childID[0...childID.rindex('!')]
+
+        parent_list = []
+        xrd.elements.each_element(CANONICALID_TAG) { |c|
+          XRI.make_xri(c.text)
+        }
+
+        if !parent_list.member?(parent_sought)
+          raise XRDSFraud.new(sprintf("%s can not come from any of %s", parent_sought,
+                                      parent_list))
+        end
+
+        childID = parent_sought
+      }
+
+      root = XRI.root_authority(iname)
+      if not XRI.provider_is_authoritative(root, childID)
+        raise XRDSFraud.new(sprintf("%s can not come from root %s", childID, root))
+      end
+
+      return canonicalID
+    end
+
+    def Yadis::mkXRDSTag(name)
+      e = REXML::Element.new('xrds:' + name)
+      e.add_namespace('xrds', XRDS_NS)
+      return e
+    end
+
+    def Yadis::mkXRDTag(name)
+      e = REXML::Element.new('xrd:' + name)
+      e.add_namespace('xrd', XRD_NS_2_0)
+      return e
+    end
+
+    ROOT_TAG = Yadis::mkXRDSTag('XRDS')
+    CANONICALID_TAG = mkXRDTag('CanonicalID')
+
+    class XRDSError < StandardError
+    end
+
+    def Yadis::parseXRDS(text)
+      if text.nil?
+        raise XRDSError.new("Not an XRDS document.")
+      end
+
+      begin
+        d = REXML::Document.new(text)
+      rescue RuntimeError => why
+        raise XRDSError.new("Not an XRDS document. Failed to parse XML.")
+      end
+
+      if is_xrds?(d)
+        return d
+      else
+        raise XRDSError.new("Not an XRDS document.")
+      end
+    end
+
+    def Yadis::is_xrds?(xrds_tree)
+      xrds_root = xrds_tree.root
+      return (!xrds_root.nil? and
+        xrds_root.name == ROOT_TAG.name and
+        xrds_root.namespace == ROOT_TAG.namespace)
+    end
+
+    def Yadis::get_yadis_xrd(xrds_tree)
+      REXML::XPath.each(xrds_tree.root,
+                        '/xrds:XRDS/xrd:XRD[last()]',
+                        XRDS_NAMESPACES) { |el|
+        return el
+      }
+      raise XRDSError.new("No XRD element found.")
+    end
+
+    # aka iterServices in Python
+    def Yadis::each_service(xrds_tree, &block)
+      xrd = get_yadis_xrd(xrds_tree)
+      xrd.each_element('Service', &block)
+    end
+
+    def Yadis::services(xrds_tree)
+      s = []
+      each_service(xrds_tree) { |service|
+        s << service
+      }
+      return s
+    end
+
+    def Yadis::expand_service(service_element)
+      es = service_element.elements
+      uris = es.each('URI') { |u| }
+      uris = prio_sort(uris)
+      types = es.each('Type/text()')
+      # REXML::Text objects are not strings.
+      types = types.collect { |t| t.to_s }
+      uris.collect { |uri| [types, uri.text, service_element] }
+    end
+
+    # Sort a list of elements that have priority attributes.
+    def Yadis::prio_sort(elements)
+      elements.sort { |a,b|
+        a.attribute('priority').to_s.to_i <=> b.attribute('priority').to_s.to_i
+      }
+    end
+  end
+end

data/lib/openid/yadis/xri.rb

@@ -0,0 +1,90 @@
+require 'openid/yadis/xrds'
+require 'openid/fetchers'
+
+module OpenID
+  module Yadis
+    module XRI
+
+      # The '(' is for cross-reference authorities, and hopefully has a
+      # matching ')' somewhere.
+      XRI_AUTHORITIES = ["!", "=", "@", "+", "$", "("]
+
+      def self.identifier_scheme(identifier)
+        if (!identifier.nil? and
+            identifier.length > 0 and
+            (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 self.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 self.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 self.to_uri_normal(xri)
+        return iri_to_uri(to_iri_normal(xri))
+      end
+
+      # RFC 3987 section 3.1
+      def self.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 self.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 self.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
+
+        self.make_xri(root)
+      end
+
+      def self.make_xri(xri)
+        if xri.index('xri://') != 0
+          xri = 'xri://' + xri
+        end
+        return xri
+      end
+    end
+  end
+end