将OOXML内联格式转换为合并元素

Question

在OOXML中，粗体，斜体等格式可以（并且经常令人烦恼）在多个元素之间分开，如下所示：

<w:p>
    <w:r>
        <w:rPr>
            <w:b/>
         </w:rPr>
         <w:t xml:space="preserve">This is a </w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t xml:space="preserve">bold </w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
            <w:i/>
        </w:rPr>
        <w:t>with a bit of italic</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t xml:space="preserve"> </w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t>paragr</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t>a</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t>ph</w:t>
    </w:r>
    <w:r>
        <w:t xml:space="preserve"> with some non-bold in it too.</w:t>
    </w:r>
</w:p>

我需要组合这些格式元素来产生这个：

<p><b>This is a mostly bold <i>with a bit of italic</i> paragraph</b> with some non-bold in it too.</p>

我最初的方法是在第一次使用时写出开始格式化标签：

 <xsl:text disable-output-escaping="yes">&lt;b&gt;</xsl:text>

然后在我处理每个<w:r>后，检查下一个，看看格式是否仍然存在。如果不是，请添加结束标记，方法与添加开始标记的方式相同。 我一直认为必须有更好的方法来做到这一点，我会对任何建议表示感谢。

还应该提到我与XSLT 1.0绑定。

需要这个的原因是我们需要在XML文件转换为OOXML之前以及从OOXML转换出来之后对它进行比较。额外的格式化标签使它看起来好像是在没有进行更改时。

Answer 1

这是一个完整的XSLT 1.0解决方案：

<xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:ext="http://exslt.org/common" xmlns:w="w"
 exclude-result-prefixes="ext w">
 <xsl:output omit-xml-declaration="yes"/>
 <xsl:strip-space elements="*"/>

 <xsl:template match="w:p">
  <xsl:variable name="vrtfPass1">
   <p>
    <xsl:apply-templates/>
   </p>
  </xsl:variable>

  <xsl:apply-templates mode="pass2"
   select="ext:node-set($vrtfPass1)/*"/>
 </xsl:template>

 <xsl:template match="w:r">
  <xsl:variable name="vrtfProps">
   <xsl:for-each select="w:rPr/*">
    <xsl:sort select="local-name()"/>
    <xsl:copy-of select="."/>
   </xsl:for-each>
  </xsl:variable>

  <xsl:call-template name="toHtml">
   <xsl:with-param name="pProps" select=
       "ext:node-set($vrtfProps)/*"/>
   <xsl:with-param name="pText" select="w:t/text()"/>
  </xsl:call-template>
 </xsl:template>

 <xsl:template name="toHtml">
  <xsl:param name="pProps"/>
  <xsl:param name="pText"/>

  <xsl:choose>
   <xsl:when test="not($pProps)">
     <xsl:copy-of select="$pText"/>
   </xsl:when>
   <xsl:otherwise>
    <xsl:element name="{local-name($pProps[1])}">
      <xsl:call-template name="toHtml">
        <xsl:with-param name="pProps" select=
            "$pProps[position()>1]"/>
        <xsl:with-param name="pText" select="$pText"/>
      </xsl:call-template>
    </xsl:element>
   </xsl:otherwise>
  </xsl:choose>
 </xsl:template>

  <xsl:template match="/*" mode="pass2">
  <xsl:copy>
    <xsl:copy-of select="@*"/>
    <xsl:call-template name="processInner">
     <xsl:with-param name="pNodes" select="node()"/>
    </xsl:call-template>
  </xsl:copy>
 </xsl:template>

 <xsl:template name="processInner">
  <xsl:param name="pNodes"/>

  <xsl:variable name="pNode1" select="$pNodes[1]"/>

  <xsl:if test="$pNode1">
   <xsl:choose>
    <xsl:when test="not($pNode1/self::*)">
     <xsl:copy-of select="$pNode1"/>
     <xsl:call-template name="processInner">
      <xsl:with-param name="pNodes" select=
      "$pNodes[position()>1]"/>
     </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="vbatchLength">
        <xsl:call-template name="getBatchLength">
         <xsl:with-param name="pNodes"
              select="$pNodes[position()>1]"/>
         <xsl:with-param name="pName"
             select="name($pNode1)"/>
         <xsl:with-param name="pCount" select="1"/>
        </xsl:call-template>
      </xsl:variable>

      <xsl:element name="{name($pNode1)}">
        <xsl:copy-of select="@*"/>

        <xsl:call-template name="processInner">
         <xsl:with-param name="pNodes" select=
         "$pNodes[not(position()>$vbatchLength)]
                        /node()"/>
        </xsl:call-template>
      </xsl:element>

      <xsl:call-template name="processInner">
       <xsl:with-param name="pNodes" select=
       "$pNodes[position()>$vbatchLength]"/>
      </xsl:call-template>
    </xsl:otherwise>
   </xsl:choose>
  </xsl:if>
 </xsl:template>

 <xsl:template name="getBatchLength">
  <xsl:param name="pNodes"/>
  <xsl:param name="pName"/>
  <xsl:param name="pCount"/>

  <xsl:choose>
   <xsl:when test=
   "not($pNodes) or not($pNodes[1]/self::*)
    or not(name($pNodes[1])=$pName)">
   <xsl:value-of select="$pCount"/>
   </xsl:when>
   <xsl:otherwise>
    <xsl:call-template name="getBatchLength">
     <xsl:with-param name="pNodes" select=
         "$pNodes[position()>1]"/>
     <xsl:with-param name="pName" select="$pName"/>
     <xsl:with-param name="pCount" select="$pCount+1"/>
    </xsl:call-template>
   </xsl:otherwise>
  </xsl:choose>
 </xsl:template>
</xsl:stylesheet>

将此转换应用于以下XML文档（基于提供的，但更复杂以显示更多边缘案例的覆盖范围）：

<w:p xmlns:w="w">
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t xml:space="preserve">This is a </w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t xml:space="preserve">bold </w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
            <w:i/>
        </w:rPr>
        <w:t>with a bit of italic</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
            <w:i/>
        </w:rPr>
        <w:t> and some more italic</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:i/>
        </w:rPr>
        <w:t> and just italic, no-bold</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t xml:space="preserve"></w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t>paragr</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t>a</w:t>
    </w:r>
    <w:r>
        <w:rPr>
            <w:b/>
        </w:rPr>
        <w:t>ph</w:t>
    </w:r>
    <w:r>
        <w:t xml:space="preserve"> with some non-bold in it too.</w:t>
    </w:r>
</w:p>

产生了想要的正确结果：

<p><b>This is a bold <i>with a bit of italic and some more italic</i></b><i> and just italic, no-bold</i><b>paragraph</b> with some non-bold in it too.</p>

<强>解释：

1. 这是两次转化。第一遍相对简单，并将源XML文档（在我们的特定情况下）转换为以下内容：

pass1结果（为了便于阅读而缩进）：

<p>
   <b>This is a </b>
   <b>bold </b>
   <b>
      <i>with a bit of italic</i>
   </b>
   <b>
      <i> and some more italic</i>
   </b>
   <i> and just italic, no-bold</i>
   <b/>
   <b>paragr</b>
   <b>a</b>
   <b>ph</b> with some non-bold in it too.</p>

0.2。 第二遍（在模式"pass2"中执行）将任意批连续且具有相同名称的元素合并到具有该名称的单个元素中。它以递归方式调用自身在合并元素的子元素上 - 因此合并任何深度的批处理。

0.3。 请注意：我们不（也不能）使用轴following-sibling::或preceding-sibling，因为只有顶层的节点（要合并）才真正是兄弟姐妹。由于这个原因，我们只是作为节点集处理所有节点。

0.4。 此解决方案完全通用 - 它在任何深度合并任意一批连续的同名元素 - 并且没有特定的名称是硬编码的。

Answer 2

这不是一个完整的解决方案，但它比尝试使用纯XSLT简单得多。根据您的来源的复杂性，它可能也不理想，但它可能值得一试。这些模板：

<xsl:template match="w:p">
  <p>
    <xsl:apply-templates />
  </p>
</xsl:template>

<xsl:template match="w:r[w:rPr/w:b]">
  <b>
    <xsl:apply-templates />
  </b>
</xsl:template>

<xsl:template match="w:r[w:rPr/w:i]">
  <i>
    <xsl:apply-templates />
  </i>
</xsl:template>

<xsl:template match="w:r[w:rPr/w:i and w:rPr/w:b]">
  <b>
    <i>
      <xsl:apply-templates />
    </i>
  </b>
</xsl:template>

将输出<p><b>This is a </b><b>bold </b><b><i>with a bit of italic</i></b><b> </b><b>paragr</b><b>a</b><b>ph</b> with some non-bold in it too.</p>

然后，您可以使用简单的文字操作删除任何</b><b>和</i><i>，并留下：

<p><b>This is a bold <i>with a bit of italic</i> paragraph</b> with some non-bold in it too.</p>

Answer 3

OOXML 是定义的标准，其 its own specification 。要创建从 OOXML 到 HTML 的常规转换（这很有趣，即使我认为应该已经存在网络上已有的实现），您应该至少研究一下标准（你需要研究一下我认为的XSLT）。

通常（非常普遍），WordML文档的内容主要由w:p（段落）元素组成，其中包含w:r 运行（具有相同属性的文本区域） 。在每次运行中，您通常可以找到区域（w:rPr）和文本本身（w:t）的文本属性。

该模型更为复杂，但您可以开始研究这种一般结构。

例如，您可以开始使用以下（一点点）常规转换。请注意，它仅管理带粗体，斜体和未标注文本的段落。

---

在 Saxon-HE 9.2.1.1J 下测试

XSLT 2.0

<xsl:stylesheet version="2.0" 
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml"
    exclude-result-prefixes="w">
    <xsl:output method="html"/>
    <xsl:strip-space elements="*"/>

    <xsl:template match="w:document/w:body">
        <html>
            <body>
                <xsl:apply-templates select="w:p"/>
            </body>
        </html>
    </xsl:template>

    <!-- match paragraph -->
    <xsl:template match="w:p">
        <p>
            <xsl:apply-templates select="w:r"/>
        </p>
    </xsl:template>

    <!-- match run with property -->
    <xsl:template match="w:r[w:rPr]">
        <xsl:apply-templates select="w:rPr/*[1]"/>
    </xsl:template>

    <!-- Recursive template for bold, italic and underline
    properties applied to the same run. Escape to paragraph
    text -->
    <xsl:template match="w:b | w:i | w:u">
        <xsl:element name="{local-name(.)}">
            <xsl:choose>
                <!-- recurse to next sibling property i, b or u -->
                <xsl:when test="count(following-sibling::*[1])=1">
                    <xsl:apply-templates select="following-sibling::*
                        [local-name(.)='i' or 
                        local-name(.)='b' or 
                        local-name(.)='u']"/>
                </xsl:when>
                <xsl:otherwise>
                    <!-- escape to text -->
                    <xsl:apply-templates select="parent::w:rPr/
                        following-sibling::w:t"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:element>
    </xsl:template>

    <!-- match run without property -->
    <xsl:template match="w:r[not(w:rPr)]">
        <xsl:apply-templates select="w:t"/>
    </xsl:template>

    <!-- match text -->
    <xsl:template match="w:t">
        <xsl:value-of select="."/>
    </xsl:template>

</xsl:stylesheet>

申请：

<w:document xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml">
    <w:body>
        <w:p>
            <w:r>
                <w:rPr>
                    <w:b/>
                </w:rPr>
                <w:t xml:space="preserve">This is a </w:t>
            </w:r>
            <w:r>
                <w:rPr>
                    <w:b/>
                </w:rPr>
                <w:t xml:space="preserve">bold </w:t>
            </w:r>
            <w:r>
                <w:rPr>
                    <w:b/>
                    <w:i/>
                </w:rPr>
                <w:t>with a bit of italic</w:t>
            </w:r>
            <w:r>
                <w:rPr>
                    <w:b/>
                </w:rPr>
                <w:t xml:space="preserve"> </w:t>
            </w:r>
            <w:r>
                <w:rPr>
                    <w:b/>
                </w:rPr>
                <w:t>paragr</w:t>
            </w:r>
            <w:r>
                <w:rPr>
                    <w:b/>
                </w:rPr>
                <w:t>a</w:t>
            </w:r>
            <w:r>
                <w:rPr>
                    <w:b/>
                </w:rPr>
                <w:t>ph</w:t>
            </w:r>
            <w:r>
                <w:t xml:space="preserve"> with some non-bold in it too.</w:t>
            </w:r>
        </w:p>
    </w:body>
</w:document>

产生

<html>
   <body>
      <p><b>This is a </b><b>bold </b><b><i>with a bit of italic</i></b><b> </b><b>paragr</b><b>a</b><b>ph</b> with some non-bold in it too.
      </p>
   </body>
</html>

---

由于WordML底层架构，具有怪诞HTML代码的副作用是不可避免的。也许使最终HTML清晰易读的任务可以推迟到一些用户友好（和强大）的实用程序，如HTML tidy。

Answer 4

另一种类似于Flynn但使用XSLT而不是添加单独的文本处理层的方法是在同一样式表中转换初始HTML输出以折叠<b>或{{1}的相邻元素单个元素。

换句话说，样式表将首先生成初始HTML结果树，然后将其作为输入传递给执行折叠操作的一组模板（使用特殊模式）。

<强>更新 这是一个有效的2阶段样式表，构建于@ empo的stage-1样式表：

<i>

再次测试您提供的样本输入时，上面的样式表产生

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
   xmlns:xs="http://www.w3.org/2001/XMLSchema" exclude-result-prefixes="xs w"
   xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml" version="2.0">

   <xsl:output method="html"/>
   <xsl:strip-space elements="*"/>
   <xsl:variable name="collapsibles" select="('i', 'b', 'u')"/>      

   <!-- identity template, except we collapse any adjacent b or i child elements. -->
   <xsl:template match="*" mode="collapse-adjacent">
      <xsl:copy>
         <xsl:copy-of select="@*"/>
         <xsl:for-each select="node()">
            <xsl:choose>
               <xsl:when test="index-of($collapsibles, local-name()) and
                     not(name(preceding-sibling::node()[1]) = name())">
                  <xsl:copy>
                     <xsl:copy-of select="@*"/>
                     <xsl:call-template name="process-niblings"/>
                  </xsl:copy>
               </xsl:when>
               <xsl:when test="index-of($collapsibles, local-name())"/>
               <!-- do not copy -->
               <xsl:otherwise>
                  <xsl:copy>
                     <xsl:copy-of select="@*"/>
                     <xsl:apply-templates mode="collapse-adjacent"/>
                  </xsl:copy>
               </xsl:otherwise>
            </xsl:choose>
         </xsl:for-each>
      </xsl:copy>
   </xsl:template>

   <!-- apply templates to children of current element *and* of all
      consecutively following elements of the same name. -->
   <xsl:template name="process-niblings">
      <xsl:apply-templates mode="collapse-adjacent"/>
      <!-- If immediate following sibling is the same element type, recurse with
         context node set to that sibling. -->
      <xsl:for-each
         select="following-sibling::node()[1][name() = name(current())]">
         <xsl:call-template name="process-niblings"/>
      </xsl:for-each>
   </xsl:template>

   <!-- @empo's stylesheet (modified) follows. --> 
   <xsl:template match="/">
      <html>
         <body>
            <xsl:variable name="raw-html">
               <xsl:apply-templates />
            </xsl:variable>
            <xsl:apply-templates select="$raw-html" mode="collapse-adjacent"/>            
         </body>
      </html>
   </xsl:template>

   <xsl:template match="w:document | w:body">
      <xsl:apply-templates />
   </xsl:template>

   <!-- match paragraph -->
   <xsl:template match="w:p">
      <p>
         <xsl:apply-templates select="w:r"/>
      </p>
   </xsl:template>

   <!-- match run with property -->
   <xsl:template match="w:r[w:rPr]">
      <xsl:apply-templates select="w:rPr/*[1]"/>
   </xsl:template>

   <!-- Recursive template for bold, italic and underline
      properties applied to the same run. Escape to paragraph
      text -->
   <xsl:template match="w:b | w:i | w:u">
      <xsl:element name="{local-name(.)}">
         <xsl:choose>
            <!-- recurse to next sibling property i, b or u -->
            <xsl:when test="count(following-sibling::*[1])=1">
               <xsl:apply-templates select="following-sibling::*
                  [index-of($collapsibles, local-name(.))]"/>
            </xsl:when>
            <xsl:otherwise>
               <!-- escape to text -->
               <xsl:apply-templates select="parent::w:rPr/
                  following-sibling::w:t"/>
            </xsl:otherwise>
         </xsl:choose>
      </xsl:element>
   </xsl:template>

   <!-- match run without property -->
   <xsl:template match="w:r[not(w:rPr)]">
      <xsl:apply-templates select="w:t"/>
   </xsl:template>

   <!-- match text -->
   <xsl:template match="w:t">
      <xsl:value-of select="."/>
   </xsl:template>

</xsl:stylesheet>

看起来像你想要的。