Converting Legacy Word Documents to XML

One of the benefits of Microsoft Office Word 2003 is that it will take any existing Word document and save it with WordML (or WordprocessingML, to be official). One of my clients has a number of documents that contain member listings. They've migrated their main body of documents (standards) to an XML environment, but the committee member lists are maintained by another group and still created in Word. My mission is to convert the legacy Word documents to XML, and then build a very simple Smart Document solution for future maintenance. You can view the target schema here, or look at the Word template here.

The first step is to open each of the legacy documents in Word 2003 and save as XML. This will allow me to use XSLT for the actual conversion. No styles were used to create these lists; the only unique component is that the actual member name is in boldface type.

They look like this:

Notice that last line; there's nothing to associate that line with the previous other than it's slightly indented (two spaces on average in the source files).

Rather than trying to create an XSLT that will result in a perfect XML instance on the first pass, I'm instead going to build this in steps, each time refining the markup until I have an instance that will be valid against the schema. Here's what I want to accomplish on the first pass:

strip any text associated with document properties or other elements that live above the start body (<w:body>) element in WordML.
insert the top-level element <CommitteeList> start and end tags
surround any centered text with a <center> element
pass through the run element (<w:r>) as r (<r>)
pass through the bold element (<w:b/>) as b ()

This will give me the hooks I need for the next pass.

Gotchas:

Apparently Smart Tags were turned on when I saved the documents as XML. This created numerous extraneous text runs in the instance. Go back, disable Smart Tags, and resave the documents.
Same goes for grammar checking. Notice the green squiggly lines in the screen snap. Everything is captured in WordML, and that includes possible spelling or grammar errors. Disable and resave.

My result documents are now much easier to read. Here's the next set of tasks to be accomplished in the second XSLT:

transform <r> elements that contain into <Name> elements
transform <r> elements that contain "(Alt" into <VotingMemberName> elements
transform content between </Name> and <Classification> as <Organization>
transform <r> elements that contain "[*]" into <Classification> elements
transform remaining <r> elements into <AdditionalInfo> elements

When you create your next stylesheet, you'll no longer need all of the namespace declarations required for WordML. You do need to make sure the markup continues to pass through and doesn't get lost.

Since all four tasks involve the <r> element, we'll need a big choice group. By creating various tests, we should be able to apply the appropriate markup. The most interesting part of this so far is testing to see if the <r> element contains a child element and then varying the output depending on whether the test is true or false. This is handled in XSLT by the choose element:

   <xsl:template match="r">
     <xsl:choose>
       <xsl:when test="child::b">
         <Name>
           <xsl:apply-templates/>
         </Name>
       </xsl:when>
       <xsl:when test="contains(.,'(Alt')">
         <VotingMemberName>
           <xsl:value-of select="."/>
         </VotingMemberName>
       </xsl:when>
       <xsl:when test="substring-before(.,'[')">
         <Organization>
         <xsl:value-of select="substring-before(.,'[')"/>
         </Organization>
         <Classification>
         <xsl:value-of  select="substring-before(substring-after(.,'['),']')"/>
         </Classification>
       </xsl:when>
       <xsl:otherwise>
         <AdditionalInfo>
           <xsl:apply-templates/>
         </AdditionalInfo>
       </xsl:otherwise>
     </xsl:choose>
   </xsl:template>

The above code first matches the <r> element. We created these from each of the runs within the WordML markup. The XSL:choose element can contain one or more when elements. Otherwise is the fall through; that is, if none of the previous when tests match, the otherwise rule is processed. We have three tests and a fall through defined above. The first test looks to see if the <r> element has a child element. In WordML, the represents bold, which in our document represents the member name. Therefore, if we find the child, we output the start/end <Name> element along with the content.

The second test searches for the string "(Alt" within the text node. If it finds the string, it then outputs an open <VotingMemberName> element, processes the text node, and then outputs the close element.

The third test is also a string test, but this time we need to make sure we output all of the content preceding the open square bracket as the <Organization> element. We then output the element <Classification> followed by everything betwen the open and close brackets, and then the close element. Our last rule processes everything else within the <AdditionalInfo> element.

The next step is to put the proper wrappers on the elements:

the first group of names should be wrapped in the <Member> element
the set of <Member> elements should be wrapped in the <PrincipalMembers> element
the group of names following the word "Alternates" should be wrapped in the <AlternateMember> element
the set of <AlternateMember> elements should be wrapped in the <Alternates> element
the group of names following the word "Nonvoting" should be wrapped in the <Member> element
the set of <Member> elements should be wrapped in the <NonvotingMembers> element

content here

Conclusions

content here.

content here