NAME
    RDF::RDFa::Generator - Generate data for RDFa serialization

DESCRIPTION
  Constructor
    `$gen = RDF::RDFa::Generator->new(style => $style, %options)`
        Creates a new generator object. $style is one of the following
        case-sensitive strings: 'HTML::Head' (the default), 'HTML::Hidden' or
        'HTML::Pretty'. You can also construct an object like this:

          $gen = RDF::RDFa::Generator::HTML::Head->new(%options);

        Options include:

        *   base - the base URL where the output data will be published. This
            allows in some cases for the generated RDFa to include relative
            URIs.

        *   data_context - if non-null, an Attean Blank or IRI object or an
            RDF::Trine::Node which indicates the context (named graph)
            containing the data to generate RDFa for.

        *   namespacemap - a URI::NamespaceMap object containing preferred
            CURIE prefixes. This is the preferred method, see note below.

        *   namespaces - a {prefix=>uri} hashref of preferred CURIE prefixes.

        *   ns - a {uri=>prefix} hashref of preferred CURIE prefixes.
            DEPRECATED - use namespaces instead.

        *   prefix_attr - use the @prefix attribute for CURIE prefixes (RDFa
            1.1 only). Boolean, defaults to false.

        *   safe_xml_literals - prevents XML literals from injecting arbitrary
            XHTML into the output. Boolean, defaults to FALSE.

        *   title - assign a <title> element for generated XHTML documents.

        *   version - set generated RDFa version. Valid values are '1.0' (the
            default) or '1.1'.

  Public Methods
    `$gen->create_document($model, %opts)`
        Creates a new RDFa file containing triples. $model is an
        RDF::Trine::Model object providing the triples. Returns an
        XML::LibXML::Document object suitable for serializing using its
        `toString` method.

        If you're planning on serving the RDFa with the text/html media type,
        then it is recommended that you use HTML::HTML5::Writer to serialize
        the document rather than `toString`.

        Can also be called as a class method:

         $document = RDF::RDFa::Generator->create_document($model)
         # Same as:
         # $document = RDF::RDFa::Generator->new->create_document($model)

        Options can also be passed as a HASH. This is typically used for
        style-specific options.

    `$gen->inject_document($document, $model)`
        Injects an existing document with triples. $document is an
        XML::LibXML::Document to inject, or a well-formed XML string. $model
        is an RDF::Trine::Model object providing the triples. Returns an
        XML::LibXML::Document object suitable for serializing using its
        `toString` method.

        See `create_document` for information about serving the RDFa with the
        text/html media type.

        Can also be called as a class method. See `create_document` for
        details.

    `$gen->nodes($model)`
        Provides triple-laden XML::LibXML::Elements to be added to a document.
        $model is an RDF::Trine::Model object providing the triples. If called
        in list context, returns a list of XML::LibXML::Element objects which
        can be added to a document; otherwise returns an XML::LibXML::NodeList
        containing a list of such elements.

        Can also be called as a class method. See `create_document` for
        details.

        The HTML::Pretty generator can be passed a couple of additional
        options:

          $gen->nodes($model, notes_heading=>'Additional Info', notes=>\@notes);

        The notes are a list of RDF::RDFa::Generator::HTML::Pretty::Note
        objects which are added as notes to the end of each subject's data.

NOTE
    Version 0.200 introduced a large number of changes to be compatible with
    both Attean and RDF::Trine. Some of these were backwards-incompatible,
    some were to support new features, such as the use of URI::NamespaceMap.

  Backwards-incompatible changes
    The methods `serialize_model_to_file`, `serialize_model_to_string`,
    `serialize_iterator_to_file` and `serialize_iterator_to_string` that were
    provided for compatibility with the RDF::Trine::Serializer interface have
    been moved to a module RDF::Trine::Serializer::RDFa that has to be
    installed separately to use this with RDF::Trine.

    `data_context` previously accepted a plain-text string URI. Now, it
    requires an appropriate object, as documented.

    Since RDF 1.1 abandons untyped literals, this module also ceases to emit
    them.

  Namespace mappings
    The way namespace mappings are handled have been rewritten. Now, the
    preferred method to add them is to pass an URI::NamespaceMap object to
    `namespacemap`. This will override any other options.

    The namespace mappings for the following prefixes will always be added:
    `rdfa`, `rdf`, `rdfs` and `xsd`.

    If URI::NamespaceMap is not used, but `namespaces` is given as a hashref
    of prefix-URI pairs, the pairs will be added. If neither are given, all
    mappings from RDF::NS::Curated, which includes all if RDFa Initial Context
    will be added. Finally, any pairs from the deprecated `ns` option will be
    added, but a warning will be emitted.

BUGS
    Please report any bugs to
    <https://github.com/kjetilk/p5-rdf-rdfa-generator/issues>.

SEE ALSO
    You may want to use the framework-specific frontends:
    RDF::Trine::Serializer::RDFa or AtteanX::Serializer::RDFa.

    Other relevant modules:

    HTML::HTML5::Writer, XML::LibXML, RDF::RDFa::Parser, RDF::Trine,
    URI::NamespaceMap, Attean.

AUTHOR
    Toby Inkster <tobyink@cpan.org>.

    Kjetil Kjernsmo <kjetilk@cpan.org>.

COPYRIGHT AND LICENCE
    Copyright (C) 2010 by Toby Inkster, 2017, 2018 Kjetil Kjernsmo

    This library is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself, either Perl version 5.8 or, at your
    option, any later version of Perl 5 you may have available.

  Icons
    RDF::RDFa::Generator::HTML::Pretty uses the FamFamFam Silk icons; see
    <http://famfamfam.com/lab/icons/silk/>.

