discodactyl 0.3.0

data/lib/discodactyl/resource_discovery.rb

@@ -0,0 +1,102 @@
+require 'open-uri'
+require 'nokogiri'
+require 'discodactyl/link_header'
+
+module Discodactyl # :nodoc:
+  class ResourceDiscovery
+    class << self
+
+      # perform LRDD on the URI, returning all linked URIs which match
+      # the provided rel. Any URITemplates will be expanded with the
+      # params if they are provided
+      #--
+      # TODO: xri support: no host
+      # TODO: check if XRD/Property[@type=http://lrdd.net/priority/resource] to indicate resource-priority
+      # TODO: handle 3** status redirects
+      # TODO: maintain a security bit
+      # TODO: URIs for all discovery modes should be appended, not just returned
+      # TODO: rewrite this so it's just get links, which yields objects providing at least the xrd link interface (rel, href, type)
+      #++
+      def get_uris_by_rel(uri, rel, params = {})
+        begin
+          uri = URI.parse(uri.to_s) unless uri.respond_to?('open')
+          resource = uri.open
+        rescue OpenURI::HTTPError => e
+          status = e.io.status[0] # => 3xx, 4xx, or 5xx
+
+          # code = Net::HTTPResponse::CODE_TO_OBJ[status]
+          # if code == "303"
+          # 303        HTTPSeeOther
+          #   if res.key? 'Link'
+          #     links = res['Link']
+          #   end
+          # elsif code == "401" # HTTPUnauthorized
+          #   authenticate
+          #   return get_uris_by_rel(uri)
+          # elsif code == "301" || status == "302"
+          # 300        HTTPMultipleChoice
+          # 301        HTTPMovedPermanently
+          # 302        HTTPFound
+          # 304        HTTPNotModified
+          # 305        HTTPUseProxy
+          # 307        HTTPTemporaryRedirect
+          #   resource = URI.parse(resource['location']).open
+          # else
+        rescue NoMethodError
+        end
+        if resource
+          # check for link headers first
+          if resource.meta.key? 'Link'
+            uris = get_uris_by_rel_from_link_header(resource, rel)
+          end
+
+          unless uris
+            # then check for links in the document
+            if content_sniff(resource) == 'text/html'
+              uris = get_uris_by_rel_from_html(resource, rel)
+            # Atom
+            elsif content_sniff(resource) == 'application/atom+xml'
+              uris = get_uris_by_rel_from_atom(resource, rel)
+            end
+          end
+        end
+        unless uris
+          host_meta = Discodactyl::HostMeta.from_uri uri
+          uris = host_meta.uris_by_rel(rel, params)
+        end
+        uris
+      end
+
+      def lrdd_discovery(uri)
+        get_uris_by_rel(uri, 'describedby')
+      end
+
+      def content_sniff(resource)
+        if resource.content_type == 'text/html'
+          type = 'text/html'
+        elsif resource.content_type == 'application/atom+xml'
+          type = 'application/atom+xml'
+        end
+        type
+      end
+
+      # take an HTTP response with a content-type of HTML,
+      # find all links by rel, and return each href
+      def get_uris_by_rel_from_html(resource, rel)
+        doc = Nokogiri::HTML(resource)
+        links = doc.xpath("//*[contains(@rel, \"#{rel}\")]")
+        uris = links.map {|link| link['href'] }
+      end
+
+      # take an HTTP response, find a link header
+      # with rel, and return its href
+      def get_uris_by_rel_from_link_header(response, rel)
+        links = [response.meta['Link']].flatten.collect {|link|
+          LinkHeader.parse(link);
+        }
+        link = links.find {|l| l[:rel].include? rel }
+        xrd = link[:href]
+      end
+    end
+  end
+end

data/lib/discodactyl/uri_template.rb

@@ -0,0 +1,32 @@
+module Discodactyl # :nodoc:
+  # Basic URI templates as used in XRD. Not to be confused with
+  # http://tools.ietf.org/html/draft-gregorio-uritemplate
+  class URITemplate
+    attr_accessor :pattern
+    def initialize(pattern)
+      @pattern = pattern
+    end
+    def to_uri(params)
+      require 'cgi'
+      uri = @pattern
+      while /\{%([^}]*)\}/ =~ uri
+        uri.gsub!($~[0], params[$~[1]])
+      end
+      while /\{([^}]*)\}/ =~ uri
+        uri.gsub!($~[0], CGI::escape(params[$~[1]].to_s))
+      end
+      uri
+    end
+
+    def ==(other)
+      return false unless other.class == self.class
+      return false unless other.instance_variables == self.instance_variables
+      self.instance_variables.each do |var|
+        self_var = self.instance_variable_get(var)
+        other_var = other.instance_variable_get(var)
+        return false unless self_var.eql?(other_var)
+      end
+      true
+    end
+  end
+end

data/lib/discodactyl/xrd.rb

@@ -0,0 +1,2 @@
+require 'discodactyl/xrd/document'
+require 'discodactyl/xrd/link'

data/lib/discodactyl/xrd/document.rb

@@ -0,0 +1,75 @@
+require 'nokogiri'
+require 'discodactyl/xrd/link'
+
+module Discodactyl # :nodoc:
+module XRD # :nodoc:
+  XMLNS = {'xrd' => 'http://docs.oasis-open.org/ns/xri/xrd-1.0'}
+  class Document
+    class << self
+      def parse(string)
+        raw = Nokogiri::XML(string)
+        doc = self.new
+
+        doc.raw = raw
+
+        doc
+      end
+    end
+
+    attr_accessor :raw
+
+    def escapeXPath(str)
+      inner = str.split('\'').join('\',"\'",\'')
+      outer = 'concat(\'\',\'%s\')' % inner
+    end
+
+    def linkelems_by_rel(rel)
+      path = '/xrd:XRD/xrd:Link[@rel=%s]'% escapeXPath(rel)
+      @raw.xpath path, XMLNS
+    end
+
+    def links_by_rel(rel)
+      linkelems_by_rel(rel).map {|e| Link.parse(e) }
+    end
+
+    def uris_by_rel(rel, params = {})
+      links_by_rel(rel).map {|l| l.to_uri(params) }
+    end
+
+    # take an XML fragment for a link and append it to the document
+    def append(link)
+      initial_ids = ids
+      raw.root.add_child(link)
+      elem = Link.parse(raw.root.last_element_child)
+      elem.id = generate_tag_uri if elem.id.nil? || initial_ids.include?(elem.id)
+      elem
+    end
+
+    def links
+      raw.xpath('/xrd:XRD/xrd:Link', XMLNS).collect {|elem|
+        Link.parse(elem)
+      }
+    end
+
+    def find_link_by_id(link_id)
+        links.find {|link| link.id == link_id}
+    end
+
+    def ids
+      links.map(&:id).reject(&:nil?)
+    end
+
+    def to_s
+      raw.to_s
+    end
+
+    def generate_tag_uri
+      scheme = 'tag'
+      authority = 'dactylo.us'
+      date = Date.today.to_s
+      specific = "/xrd/link/#{rand(2**10)}"
+      "#{scheme}:#{authority},#{date}:#{specific}"
+    end
+  end
+end
+end

data/lib/discodactyl/xrd/link.rb

@@ -0,0 +1,47 @@
+require 'nokogiri'
+require 'active_support/core_ext/object/misc'
+require 'discodactyl/uri_template'
+
+module Discodactyl # :nodoc:
+module XRD # :nodoc:
+  class Link
+    class << self
+      def parse(element)
+        returning(link = self.new) do
+          link.rel = element['rel']
+          link.type = element['type']
+          link.href = element['href']
+          link.template = URITemplate.new(element['template']) unless link.href
+          link.raw = element
+        end
+      end
+    end
+
+    attr_accessor :href, :template, :rel, :type, :raw
+
+    def to_uri(params = {})
+      @href || @template.to_uri(params)
+    end
+
+    def id
+      begin
+        @raw.attribute_with_ns('id', 'http://www.w3.org/XML/1998/namespace').value
+      rescue
+      end
+    end
+
+    def id=(value)
+      @raw['xml:id'] = value
+    end
+
+    def to_s
+      @raw.to_s
+    end
+
+    def ==(other)
+      (other.respond_to?('raw') && (@raw == other.raw)) ||
+      super
+    end
+  end
+end
+end

data/test/test_acct_uri.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby -w
+libdir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require "test/unit"
+require "discodactyl/acct_uri"
+
+class TestURIAcct < Test::Unit::TestCase
+  def test_parse_without_scheme
+    a = URI::ACCT.parse('user@host.example')
+    assert_equal('user', a.local_part)
+    assert_equal('host.example', a.host)
+  end
+
+  def test_parse_with_scheme
+    a = URI::ACCT.parse('acct:user@host.example')
+    assert_equal('user', a.local_part)
+    assert_equal('host.example', a.host)
+  end
+
+  def test_parse_uri_by_scheme
+    a = URI.parse('acct:user@host.example')
+    assert_equal('user', a.local_part)
+    assert_equal('host.example', a.host)
+  end
+
+  def test_build_from_hash
+    a = URI::ACCT.build(:local_part => 'user',
+      :host => 'host.example')
+    assert_equal('user', a.local_part)
+    assert_equal('host.example', a.host)
+  end
+
+  def test_build_from_opaque
+    a = URI::ACCT.build(:opaque => 'user@host.example')
+    assert_equal('user', a.local_part)
+    assert_equal('host.example', a.host)
+  end
+
+  def test_build_from_array
+    a = URI::ACCT.build(['user','host.example'])
+    assert_equal('user', a.local_part)
+    assert_equal('host.example', a.host)
+  end
+
+
+  def test_to_s
+    a = URI::ACCT.build(:local_part => 'user',
+      :host => 'host.example')
+    assert_equal('acct:user@host.example', a.to_s)
+  end
+  def test_id
+    a = URI::ACCT.build(:local_part => 'user',
+      :host => 'host.example')
+    assert_equal('user@host.example', a.id)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require "test/unit"
+module Test::Unit::Assertions
+  def assert_length(expected, enum, message = nil)
+    message = build_message message, '<?> is not length <?>', enum, expected
+    assert_equal expected, enum.length, message
+  end
+
+  def assert_include?(atom, enum, message = nil)
+    message = build_message message, '<?> does not include <?>.', enum, atom
+    assert enum.include?(atom), message
+  end
+end
+
+class Test::Unit::TestCase
+  require 'rr'
+  include RR::Adapters::TestUnit
+end

data/test/test_host_meta.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby -w
+libdir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require "test/unit"
+require "discodactyl/host_meta"
+require "discodactyl/acct_uri"
+
+class TestHostMeta < Test::Unit::TestCase
+  def test_get_uri_from_host
+    uri = 'host.example'
+    expected = URI.parse 'http://host.example/.well-known/host-meta'
+    assert_equal expected, Discodactyl::HostMeta.get_uri_from_uri(uri)
+  end
+
+  def test_get_uri_from_http
+    uri = URI.parse 'http://host.example/some/path'
+    expected = URI.parse 'http://host.example/.well-known/host-meta'
+    assert_equal expected, Discodactyl::HostMeta.get_uri_from_uri(uri)
+  end
+
+  def test_get_uri_from_acct
+    uri = URI.parse 'acct:user@host.example'
+    expected = URI.parse 'http://host.example/.well-known/host-meta'
+    assert_equal expected, Discodactyl::HostMeta.get_uri_from_uri(uri)
+  end
+
+  # def test_raise_meaningful_exception
+  #   stub(io).status { [ '404', 'Not Found'] }
+  #   stub(uri).open { raise OpenURI::HTTPError.new('foo', io)}
+  #   stub(URI).parse('http://example.com/.well-known/host-meta') { uri }
+  #
+  #   assert_raise Discodactyl::HostMetaHTTPError, "404 Not Found" do
+  #     Discodactyl::HostMeta.from_uri(uri)
+  #   end
+  # end
+end

data/test/test_link_header.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby -w
+libdir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require "test/unit"
+require "discodactyl/link_header"
+
+class TestLinkHeader < Test::Unit::TestCase
+  def test_parse_rel_and_title
+    link = '<http://example.com/TheBook/chapter2>; rel="previous"; title="previous chapter"'
+    expected = {:href => 'http://example.com/TheBook/chapter2', :rel => ['previous'], :title => 'previous chapter'}
+    assert_equal expected, Discodactyl::LinkHeader.parse(link)
+  end
+  
+  def test_parse_seperated_rels
+    link = '<http://example.org/>; rel=index; rel="start http://example.net/relation/other"'
+    expected = {:href => 'http://example.org/', :rel => ['index', 'start', 'http://example.net/relation/other']}
+    assert_equal expected, Discodactyl::LinkHeader.parse(link)
+  end
+  
+  def test_parse_simple_link
+    link = '</bar>; rel="http://example.com/profile1/foo"'
+    expected = {:href => '/bar', :rel => ['http://example.com/profile1/foo']}
+    assert_equal expected, Discodactyl::LinkHeader.parse(link)
+  end
+  
+  def test_parse_xrd_link
+    link = '<http://josephholsten.com/descriptor.xrd>; rel="describedby"; type="application/xrd+xml"'
+    expected = {:href => 'http://josephholsten.com/descriptor.xrd', :rel => ['describedby'], :type => 'application/xrd+xml' }
+    assert_equal expected, Discodactyl::LinkHeader.parse(link)
+  end
+end

data/test/test_resource_discovery.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby -w
+libdir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+testdir = File.expand_path('../../test', __FILE__)
+$LOAD_PATH.unshift(testdir) unless $LOAD_PATH.include?(testdir)
+
+require 'test_helper'
+require "test/unit"
+require "discodactyl/resource_discovery"
+
+class TestResourceDiscovery < Test::Unit::TestCase
+  def test_get_uris_by_rel_from_html
+    raw = '<html><head><title></title><link rel="describedby" href="http://host.example/description.xrd"></head><body></body></html>'
+
+    uris = Discodactyl::ResourceDiscovery.get_uris_by_rel_from_html(raw, 'describedby')
+
+    assert_include? 'http://host.example/description.xrd', uris
+  end
+
+  def test_get_uris_by_rel_from_html_with_multiple_rels
+    raw = '<html><head><title></title><link rel="also describedby" href="http://host.example/description.xrd"></head><body></body></html>'
+
+    uris = Discodactyl::ResourceDiscovery.get_uris_by_rel_from_html(raw, 'describedby')
+
+    assert_include? 'http://host.example/description.xrd', uris
+  end
+
+  def test_get_uris_by_rel_from_html_via_disco
+    require 'ostruct'
+    raw = '<html><head><title></title><link rel="describedby" href="http://host.example/description.xrd"></head><body></body></html>'
+    response = FakeResp.new(raw)
+    response.meta = {}
+    response.content_type = 'text/html'
+    uri = OpenStruct.new(:open => response)
+
+    uris = Discodactyl::ResourceDiscovery.get_uris_by_rel(uri, 'describedby')
+
+    assert_include? 'http://host.example/description.xrd', uris
+  end
+
+  def test_get_uris_by_rel_from_link_header
+    require 'ostruct'
+    header = '<http://host.example/description.xrd>; rel="describedby"'
+    response = OpenStruct.new(:meta => {'Link' => header})
+
+    uris = Discodactyl::ResourceDiscovery.get_uris_by_rel_from_link_header(response, 'describedby')
+
+    assert_equal 'http://host.example/description.xrd', uris
+  end
+
+  def test_get_uris_by_rel_from_header
+    require 'ostruct'
+    header = '<http://host.example/description.xrd>; rel="describedby"'
+    response = OpenStruct.new(:meta => {'Link' => header})
+    uri = OpenStruct.new(:open => response)
+
+    uris = Discodactyl::ResourceDiscovery.get_uris_by_rel(uri, 'describedby')
+
+    assert_equal 'http://host.example/description.xrd', uris
+  end
+end
+
+class FakeResp < String
+  attr_accessor :meta, :content_type
+end