Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Read-only release history for XRD-Parser
Perl

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
examples
inc
lib/XRD
meta
t
Changes
LICENSE
MANIFEST
META.yml
Makefile.PL
README
SIGNATURE

README

NAME
    XRD::Parser - parse XRD and host-meta files into RDF::Trine models

SYNOPSIS
      use RDF::Query;
      use XRD::Parser;
  
      my $parser = XRD::Parser->new(undef, "http://example.com/foo.xrd");
      my $results = RDF::Query->new(
        "SELECT * WHERE {?who <http://spec.example.net/auth/1.0> ?auth.}")
        ->execute($parser->graph);
        
      while (my $result = $results->next)
      {
        print $result->{'auth'}->uri . "\n";
      }

    or maybe:

      my $data = XRD::Parser->hostmeta('gmail.com')
                              ->graph
                                ->as_hashref;

DESCRIPTION
    While XRD has a rather different history, it turns out it can mostly be
    thought of as a serialisation format for a limited subset of RDF.

    This package ignores the order of <Link> elements, as RDF is a graph
    format with no concept of statements coming in an "order". The XRD spec
    says that grokking the order of <Link> elements is only a SHOULD. That
    said, if you're concerned about the order of <Link> elements, the
    callback routines allowed by this package may be of use.

    This package aims to be roughly compatible with RDF::RDFa::Parser's
    interface.

  Constructors
    "$p = XRD::Parser->new($content, $uri, [\%options], [$store])"
        This method creates a new XRD::Parser object and returns it.

        The $content variable may contain an XML string, or a
        XML::LibXML::Document. If a string, the document is parsed using
        XML::LibXML::Parser, which may throw an exception. XRD::Parser does
        not catch the exception.

        $uri the base URI of the content; it is used to resolve any relative
        URIs found in the XRD document.

        Options [default in brackets]:

        *       default_subject - If no <Subject> element. [undef]

        *       link_prop - How to handle <Property> in <Link>? 0=skip,
                1=reify, 2=subproperty, 3=both. [0]

        *       loose_mime - Accept text/plain, text/html and
                application/octet-stream media types. [0]

        *       tdb_service - Use thing-described-by.org when possible. [0]

        $storage is an RDF::Trine::Storage object. If undef, then a new
        temporary store is created.

    "$p = XRD::Parser->new_from_url($url, [\%options], [$storage])"
        $url is a URL to fetch and parse.

        This function can also be called as "new_from_uri". Same thing.

    "$p = XRD::Parser->hostmeta($uri)"
        This method creates a new XRD::Parser object and returns it.

        The parameter may be a URI (from which the hostname will be
        extracted) or just a bare host name (e.g. "example.com"). The
        resource "/.well-known/host-meta" will then be fetched from that
        host using an appropriate HTTP Accept header, and the parser object
        returned.

  Public Methods
    "$p->uri($uri)"
        Returns the base URI of the document being parsed. This will usually
        be the same as the base URI provided to the constructor.

        Optionally it may be passed a parameter - an absolute or relative
        URI - in which case it returns the same URI which it was passed as a
        parameter, but as an absolute URI, resolved relative to the
        document's base URI.

        This seems like two unrelated functions, but if you consider the
        consequence of passing a relative URI consisting of a zero-length
        string, it in fact makes sense.

    "$p->dom"
        Returns the parsed XML::LibXML::Document.

    "$p->graph"
        This method will return an RDF::Trine::Model object with all
        statements of the full graph.

        This method will automatically call "consume" first, if it has not
        already been called.

    $p->set_callbacks(\%callbacks)
        Set callback functions for the parser to call on certain events.
        These are only necessary if you want to do something especially
        unusual.

          $p->set_callbacks({
            'pretriple_resource' => sub { ... } ,
            'pretriple_literal'  => sub { ... } ,
            'ontriple'           => undef ,
            });

        Either of the two pretriple callbacks can be set to the string
        'print' instead of a coderef. This enables built-in callbacks for
        printing Turtle to STDOUT.

        For details of the callback functions, see the section CALLBACKS.
        "set_callbacks" must be used *before* "consume". "set_callbacks"
        itself returns a reference to the parser object itself.

        *NOTE:* the behaviour of this function was changed in version 0.05.

    "$p->consume"
        This method processes the input DOM and sends the resulting triples
        to the callback functions (if any).

        It called again, does nothing.

        Returns the parser object itself.

  Utility Functions
    "$host_uri = XRD::Parser::host_uri($uri)"
        Returns a URI representing the host. These crop up often in graphs
        gleaned from host-meta files.

        $uri can be an absolute URI like 'http://example.net/foo#bar' or a
        host name like 'example.com'.

    "$uri = XRD::Parser::template_uri($relationship_uri)"
        Returns a URI representing not a normal relationship, but the
        relationship between a host and a template URI literal.

    "$hostmeta_uri = XRD::Parser::hostmeta_location($host)"
        The parameter may be a URI (from which the hostname will be
        extracted) or just a bare host name (e.g. "example.com"). The
        location for a host-meta file relevant to the host of that URI will
        be calculated.

        If called in list context, returns an 'https' URI and an 'http' URI
        as a list.

CALLBACKS
    Several callback functions are provided. These may be set using the
    "set_callbacks" function, which taskes a hashref of keys pointing to
    coderefs. The keys are named for the event to fire the callback on.

  pretriple_resource
    This is called when a triple has been found, but before preparing the
    triple for adding to the model. It is only called for triples with a
    non-literal object value.

    The parameters passed to the callback function are:

    *   A reference to the "XRD::Parser" object

    *   A reference to the "XML::LibXML::Element" being parsed

    *   Subject URI or bnode (string)

    *   Predicate URI (string)

    *   Object URI or bnode (string)

    The callback should return 1 to tell the parser to skip this triple (not
    add it to the graph); return 0 otherwise.

  pretriple_literal
    This is the equivalent of pretriple_resource, but is only called for
    triples with a literal object value.

    The parameters passed to the callback function are:

    *   A reference to the "XRD::Parser" object

    *   A reference to the "XML::LibXML::Element" being parsed

    *   Subject URI or bnode (string)

    *   Predicate URI (string)

    *   Object literal (string)

    *   Datatype URI (string or undef)

    *   Language (string or undef)

    The callback should return 1 to tell the parser to skip this triple (not
    add it to the graph); return 0 otherwise.

  ontriple
    This is called once a triple is ready to be added to the graph. (After
    the pretriple callbacks.) The parameters passed to the callback function
    are:

    *   A reference to the "XRD::Parser" object

    *   A reference to the "XML::LibXML::Element" being parsed

    *   An RDF::Trine::Statement object.

    The callback should return 1 to tell the parser to skip this triple (not
    add it to the graph); return 0 otherwise. The callback may modify the
    RDF::Trine::Statement object.

WHY RDF?
    It abstracts away the structure of the XRD file, exposing just the
    meaning of its contents. Two XRD files with the same meaning should end
    up producing more or less the same RDF data, even if they differ
    significantly at the syntactic level.

    If you care about the syntax of an XRD file, then use XML::LibXML.

SEE ALSO
    RDF::Trine, RDF::Query, RDF::RDFa::Parser.

    <http://www.perlrdf.org/>.

AUTHOR
    Toby Inkster, <tobyink@cpan.org>

COPYRIGHT AND LICENCE
    Copyright (C) 2009-2012 by Toby Inkster

    This library is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself.

DISCLAIMER OF WARRANTIES
    THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
    WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
    MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

Something went wrong with that request. Please try again.