RDFaImportHelper.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include <RDFaImportHelper.hxx>
 
#include <utility>
#include <xmloff/xmlimp.hxx>
#include <xmloff/namespacemap.hxx>
 
#include <comphelper/sequence.hxx>
 
#include <com/sun/star/rdf/URI.hpp>
#include <com/sun/star/rdf/XDocumentRepository.hpp>
#include <com/sun/star/rdf/XRepositorySupplier.hpp>
 
#include <rtl/ustring.hxx>
#include <sal/log.hxx>
 
#include <map>
 
using namespace ::com::sun::star;
 
namespace xmloff {
 
namespace {
 
class RDFaReader
{
    const SvXMLImport & m_rImport;
 
    const SvXMLImport & GetImport() const { return m_rImport; }
 
    //FIXME: this is an ugly hack to workaround buggy SvXMLImport::GetAbsolute
    OUString GetAbsoluteReference(OUString const & i_rURI) const
    {
        if (i_rURI.isEmpty() || i_rURI[0] == '#')
        {
            return GetImport().GetBaseURL() + i_rURI;
        }
        else
        {
            return GetImport().GetAbsoluteReference(i_rURI);
        }
    }
 
public:
    explicit RDFaReader(SvXMLImport const & i_rImport)
        : m_rImport(i_rImport)
    { }
 
    // returns URI or blank node!
    OUString ReadCURIE(OUString const & i_rCURIE) const;
 
    std::vector< OUString >
    ReadCURIEs(OUString const & i_rCURIEs) const;
 
    OUString
    ReadURIOrSafeCURIE( OUString const & i_rURIOrSafeCURIE) const;
};
 
class RDFaInserter
{
    const uno::Reference<uno::XComponentContext> m_xContext;
    uno::Reference< rdf::XDocumentRepository > m_xRepository;
 
    typedef ::std::map< OUString, uno::Reference< rdf::XBlankNode > >
        BlankNodeMap_t;
 
    BlankNodeMap_t m_BlankNodeMap;
 
public:
    RDFaInserter(uno::Reference<uno::XComponentContext> i_xContext,
            uno::Reference< rdf::XDocumentRepository > i_xRepository)
        : m_xContext(std::move(i_xContext))
        , m_xRepository(std::move(i_xRepository))
    {}
 
    uno::Reference< rdf::XBlankNode >
    LookupBlankNode(OUString const & i_rNodeId );
 
    uno::Reference< rdf::XURI >
    MakeURI( OUString const & i_rURI) const;
 
    uno::Reference< rdf::XResource>
    MakeResource( OUString const & i_rResource);
 
    void InsertRDFaEntry(struct RDFaEntry const & i_rEntry);
};
 
}
 
struct ParsedRDFaAttributes
{
    OUString m_About;
    ::std::vector< OUString > m_Properties;
    OUString m_Content;
    OUString m_Datatype;
 
    ParsedRDFaAttributes(
            OUString i_sAbout,
            ::std::vector< OUString >&& i_rProperties,
            OUString i_sContent,
            OUString i_sDatatype)
        : m_About(std::move(i_sAbout))
        , m_Properties(std::move(i_rProperties))
        , m_Content(std::move(i_sContent))
        , m_Datatype(std::move(i_sDatatype))
    { }
};
 
struct RDFaEntry
{
    uno::Reference<rdf::XMetadatable> m_xObject;
    std::shared_ptr<ParsedRDFaAttributes> m_xRDFaAttributes;
 
    RDFaEntry(uno::Reference<rdf::XMetadatable> i_xObject,
            std::shared_ptr<ParsedRDFaAttributes> i_pRDFaAttributes)
        : m_xObject(std::move(i_xObject))
        , m_xRDFaAttributes(std::move(i_pRDFaAttributes))
    { }
};
 
static bool isWS(const sal_Unicode i_Char)
{
    return ('\t' == i_Char) || ('\n' == i_Char) || ('\r' == i_Char)
        || (' ' == i_Char);
}
 
static OUString splitAtWS(OUString & io_rString)
{
    const sal_Int32 len( io_rString.getLength() );
    sal_Int32 idxstt(0);
    while ((idxstt < len) && ( isWS(io_rString[idxstt])))
        ++idxstt; // skip leading ws
    sal_Int32 idxend(idxstt);
    while ((idxend < len) && (!isWS(io_rString[idxend])))
        ++idxend; // the CURIE
    const OUString ret(io_rString.copy(idxstt, idxend - idxstt));
    io_rString = io_rString.copy(idxend); // rest
    return ret;
}
 
OUString
RDFaReader::ReadCURIE(OUString const & i_rCURIE) const
{
    // the RDFa spec says that a prefix is required (it may be empty: ":foo")
    const sal_Int32 idx( i_rCURIE.indexOf(':') );
    if (idx >= 0)
    {
        OUString Prefix;
        OUString LocalName;
        OUString Namespace;
        // LocalName may contain ':', see "ipchar" in RFC 3987
        sal_uInt16 nKey( GetImport().GetNamespaceMap().GetKeyByQName(
            i_rCURIE, &Prefix, &LocalName, &Namespace, SvXMLNamespaceMap::QNameMode::AttrValue) );
        if ( Prefix == "_" )
        {
            // eeek, it's a bnode!
            // "_" is not a valid URI scheme => we can identify bnodes
            return i_rCURIE;
        }
        else
        {
            SAL_WARN_IF(XML_NAMESPACE_NONE == nKey, "xmloff.core", "no namespace?");
            if ((XML_NAMESPACE_UNKNOWN != nKey) &&
                (XML_NAMESPACE_XMLNS   != nKey))
            {
                // N.B.: empty LocalName is valid!
                const OUString URI(Namespace + LocalName);
                return GetAbsoluteReference(URI);
            }
            else
            {
                SAL_INFO("xmloff.core", "ReadCURIE: invalid CURIE: invalid prefix" );
                return OUString();
            }
        }
    }
    SAL_INFO("xmloff.core", "ReadCURIE: invalid CURIE: no prefix" );
    return OUString();
}
 
::std::vector< OUString >
RDFaReader::ReadCURIEs(OUString const & i_rCURIEs) const
{
    std::vector< OUString > vec;
    OUString CURIEs(i_rCURIEs);
    do {
      OUString curie( splitAtWS(CURIEs) );
      if (!curie.isEmpty())
      {
          const OUString uri(ReadCURIE(curie));
          if (!uri.isEmpty())
          {
              vec.push_back(uri);
          }
      }
    }
    while (!CURIEs.isEmpty());
    if (vec.empty())
    {
        SAL_INFO("xmloff.core", "ReadCURIEs: invalid CURIEs" );
    }
    return vec;
}
 
OUString
RDFaReader::ReadURIOrSafeCURIE(OUString const & i_rURIOrSafeCURIE) const
{
    const sal_Int32 len(i_rURIOrSafeCURIE.getLength());
    if (len && (i_rURIOrSafeCURIE[0] == '['))
    {
        if ((len >= 2) && (i_rURIOrSafeCURIE[len - 1] == ']'))
        {
            return ReadCURIE(i_rURIOrSafeCURIE.copy(1, len - 2));
        }
        else
        {
            SAL_INFO("xmloff.core", "ReadURIOrSafeCURIE: invalid SafeCURIE" );
            return OUString();
        }
    }
    else
    {
        if (i_rURIOrSafeCURIE.startsWith("_:")) // blank node
        {
            SAL_INFO("xmloff.core", "ReadURIOrSafeCURIE: invalid URI: scheme is _" );
            return OUString();
        }
        else
        {
            return GetAbsoluteReference(i_rURIOrSafeCURIE);
        }
    }
}
 
uno::Reference< rdf::XBlankNode >
RDFaInserter::LookupBlankNode(OUString const & i_rNodeId )
{
    uno::Reference< rdf::XBlankNode > & rEntry( m_BlankNodeMap[ i_rNodeId ] );
    if (!rEntry.is())
    {
        rEntry = m_xRepository->createBlankNode();
    }
    return rEntry;
}
 
uno::Reference< rdf::XURI >
RDFaInserter::MakeURI( OUString const & i_rURI) const
{
    if (i_rURI.startsWith("_:")) // blank node
    {
        SAL_INFO("xmloff.core", "MakeURI: cannot create URI for blank node");
        return nullptr;
    }
    else
    {
        try
        {
            return rdf::URI::create( m_xContext, i_rURI );
        }
        catch (uno::Exception &)
        {
            SAL_WARN("xmloff.core", "MakeURI: cannot create URI");
            return nullptr;
        }
    }
}
 
uno::Reference<rdf::XResource>
RDFaInserter::MakeResource( OUString const & i_rResource)
{
    if (i_rResource.startsWith("_:")) // blank node
    {
        // we cannot use the blank node label as-is: it must be distinct
        // from labels in other graphs, so create fresh ones per XML stream
        // N.B.: content.xml and styles.xml are distinct graphs
        OUString name( i_rResource.copy(2) );
        const uno::Reference< rdf::XBlankNode > xBNode( LookupBlankNode(name) );
        SAL_WARN_IF(!xBNode.is(), "xmloff.core", "no blank node?");
        return xBNode;
    }
    else
    {
        return MakeURI( i_rResource );
    }
}
 
void RDFaInserter::InsertRDFaEntry(
    struct RDFaEntry const & i_rEntry)
{
    SAL_WARN_IF(!i_rEntry.m_xObject.is(), "xmloff.core", "InsertRDFaEntry: invalid arg: null object");
    if (!i_rEntry.m_xObject.is()) return;
 
    const uno::Reference< rdf::XResource > xSubject(
        MakeResource( i_rEntry.m_xRDFaAttributes->m_About ) );
    if (!xSubject.is())
    {
        return; // invalid
    }
 
    ::std::vector< uno::Reference< rdf::XURI > > predicates;
 
    predicates.reserve(i_rEntry.m_xRDFaAttributes->m_Properties.size());
 
    for (OUString const& prop : i_rEntry.m_xRDFaAttributes->m_Properties)
    {
        auto const xURI(MakeURI(prop));
        if (xURI.is())
        {
            predicates.push_back(xURI);
        }
    }
 
    if (predicates.empty())
    {
        return; // invalid
    }
 
    uno::Reference<rdf::XURI> xDatatype;
    if (!i_rEntry.m_xRDFaAttributes->m_Datatype.isEmpty())
    {
        xDatatype = MakeURI( i_rEntry.m_xRDFaAttributes->m_Datatype );
    }
 
    try
    {
        // N.B.: this will call xMeta->ensureMetadataReference, which is why
        // this must be done _after_ importing the whole XML file,
        // to prevent collision between generated ids and ids in the file
        m_xRepository->setStatementRDFa(xSubject, comphelper::containerToSequence(predicates),
            i_rEntry.m_xObject,
            i_rEntry.m_xRDFaAttributes->m_Content, xDatatype);
    }
    catch (uno::Exception &)
    {
        SAL_WARN("xmloff.core", "InsertRDFaEntry: setStatementRDFa failed?");
    }
}
 
RDFaImportHelper::RDFaImportHelper(const SvXMLImport & i_rImport)
    : m_rImport(i_rImport)
{
}
 
RDFaImportHelper::~RDFaImportHelper()
{
}
 
std::shared_ptr<ParsedRDFaAttributes>
RDFaImportHelper::ParseRDFa(
    OUString const & i_rAbout,
    OUString const & i_rProperty,
    OUString const & i_rContent,
    OUString const & i_rDatatype)
{
    if (i_rProperty.isEmpty())
    {
        SAL_INFO("xmloff.core", "AddRDFa: invalid input: xhtml:property empty");
        return std::shared_ptr<ParsedRDFaAttributes>();
    }
    // must parse CURIEs here: need namespace declaration context
    RDFaReader reader(GetImport());
    const OUString about( reader.ReadURIOrSafeCURIE(i_rAbout) );
    if (about.isEmpty()) {
        return std::shared_ptr<ParsedRDFaAttributes>();
    }
    ::std::vector< OUString > properties(
        reader.ReadCURIEs(i_rProperty) );
    if (properties.empty()) {
        return std::shared_ptr<ParsedRDFaAttributes>();
    }
    const OUString datatype( !i_rDatatype.isEmpty()
        ?   reader.ReadCURIE(i_rDatatype)
        :   OUString() );
    return std::make_shared<ParsedRDFaAttributes>(
            about, std::move(properties), i_rContent, datatype);
}
 
void
RDFaImportHelper::AddRDFa(
    uno::Reference<rdf::XMetadatable> const & i_xObject,
    std::shared_ptr<ParsedRDFaAttributes> const & i_pRDFaAttributes)
{
    if (!i_xObject.is())
    {
        SAL_WARN("xmloff.core", "AddRDFa: invalid arg: null textcontent");
        return;
    }
    if (!i_pRDFaAttributes)
    {
        SAL_WARN("xmloff.core", "AddRDFa: invalid arg: null RDFa attributes");
        return;
    }
    m_RDFaEntries.emplace_back(i_xObject, i_pRDFaAttributes);
}
 
void
RDFaImportHelper::ParseAndAddRDFa(
    uno::Reference<rdf::XMetadatable> const & i_xObject,
    OUString const & i_rAbout,
    OUString const & i_rProperty,
    OUString const & i_rContent,
    OUString const & i_rDatatype)
{
    std::shared_ptr<ParsedRDFaAttributes> pAttributes(
        ParseRDFa(i_rAbout, i_rProperty, i_rContent, i_rDatatype) );
    if (pAttributes)
    {
        AddRDFa(i_xObject, pAttributes);
    }
}
 
void RDFaImportHelper::InsertRDFa(
    uno::Reference< rdf::XRepositorySupplier> const & i_xModel)
{
    SAL_WARN_IF(!i_xModel.is(), "xmloff.core", "InsertRDFa: invalid arg: model null");
    if (!i_xModel.is()) return;
    const uno::Reference< rdf::XDocumentRepository > xRepository(
        i_xModel->getRDFRepository(), uno::UNO_QUERY);
    SAL_WARN_IF(!xRepository.is(), "xmloff.core", "InsertRDFa: no DocumentRepository?");
    if (!xRepository.is()) return;
    RDFaInserter inserter(GetImport().GetComponentContext(), xRepository);
    for (const auto& RDFaEntry : m_RDFaEntries)
        inserter.InsertRDFaEntry(RDFaEntry);
}
 
} // namespace xmloff
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */