< JohnBabich | Sandbox
m (Used SCM in place of CVS) |
|||
Line 192: | Line 192: | ||
=== Stage A === | === Stage A === | ||
The Doc<code></code>Book XML source module is checked out of | The Doc<code></code>Book XML source module is checked out of the SCM by the writer. The writer edits the document using the Emacs editor with PSGML and nXML mode addons. The writer thens checks the module back into SCM, requesting an editorial review. | ||
=== Stage B === | === Stage B === |
Revision as of 22:31, 25 June 2009
FOSS Docs Toolchain
Contents:
INTRODUCTION
DESIGN ASSUMPTIONS
- The documents are licensed under the Open Publication License (OPL) or compatible license.
- Only FOSS tools with mutually compatible licenses are used in the tool chain.
- Existing tools are used whenever possible.
- Open standards, in file formats, data structures, communications protocols and programming interfaces, are used whenever possible.
- New tools are designed to be modular and extensible.
- The resulting process is flexible enough to be performed manually or programmatically, run from the CLI or the GUI, on the client side or on the server side, and allows for choice of favorite editor, SCM and other tools.
- Python is the preferred scripting tool.
- The initial implementation is intended for Fedora Linux, but can easily be ported to other distributions, and even other operating systems platforms.
- If packaged as a complete system, the resulting tool set is licensed under the GPL.
THE DOCUMENTATION WORKFLOW CYCLE
The four stages in the Documentation Workflow Cycle (Patent Pending - Not!) are:
(A) Distributive editing, where writer edits documentation online wiki-style or offline with tagline-capable editor. The writer gets task assignments through Bugzilla. Material edited offline is reposted to the wiki for review and/or further revision by team members.
(B) Editorial review, wiki content reviewed by editors, before it is checked into CVS. Editorial functions include document version tracking, selection of best material from multiple versions, spell checking, and conversion of text to DocBook for storage in CVS. Note that Doc
Book conversion may be done manually or automatically.
(C) Persistent storage, edited DocBook document is checked into the version control system, along with its revision history. Source Control Management (SCM) can be performed using a variety of packages. The Fedora Project currently uses CVS.
(D) Static content, posted on website, generated automatically from CVS or equivalent version control system. This function would be enhanced by Plone in our scenario.
What follows is a preliminary outline of the steps within each stage.
STAGE A: Distributive Editing [Create/Edit Document]
First of all, there are two major options in editing the document.
OPTION 1: Offline via Client-side Editor
Simple GUI ASCII Text Editors:
- gedit (GNOME)
- KEDIT (KDE)
- MousePad (xfce)
Sophisticated Macro CLI/GUI Editors:
- Emacs with PSGML and/or nXML mode addons
- Vim with xmledit script
- GUI Editors with Plugins:
- gedit with Taglist Plugin
- KATE with XML Plugin
Advanced Markup GUI Editors:
- Bluefish (GNOME)
- IMView (GNOME)
- KXML (KDE)
WYSIWYG GUI Editors:
- Conglomerate (GNOME)
- Quanta Plus (KDE)
- Vex (JAVA Eclipse Platform)
Advanced Word Processors:
- OpenOffice.org Writer with OOo2DBK plugin
- KOffice KWord (Doc
Book SGML support, but no XML)
- AbiWord (limited Doc
Book import/export support)
OPTION 2: Online via Server-side Editor
Wiki-based Editors
- Built-in editor for Moin
Moin Wiki
- Kupu Editor for Plone CMS Wiki
STAGE B: Editorial Review [2-Stage Document Processing]
STAGE B1 - Input
- Wiki Markup Language (Moin
Moin or equivalent)
- OpenOffice Document (*.odf or *.swx)
STAGE B1 - Processing
- Convert input document into valid Doc
Book XML with DTD (Document Type Definition)
STAGE B1 - Output / STAGE B2 - Input
- Valid Doc
Book XML
- Input to Stage C
STAGE B2 - Processing
- Convert Doc
Book XML into final output format
STAGE B2 - Output
- HTML
- Wiki Markup Language
Input to Stage D
STAGE C: Persistent Storage [Check-in/Check-out]
- Doc
Book source is checked into SCM (CVS or Subversion)
- Revision history is automatically updated
- Doc
Book XML source is now available for editing/distribution/adaptation/publishing
STAGE D: Static Content [Display/Publish/Print]
- Wiki content is updated
- PDF is made available for download from website
- HTML source is generated for website
- Other formats are generated as needed
A Real-world Example
This scenario mirrors the procedure for updating source code in a program.
An existing document is published as a series of HTML web pages on a web site. It also is available for downloading as a PDF document. The original source is stored in DocBook XML format in CVS. Several "bugs" are filed against the document in Bugzilla, requiring it to be updated/corrected.
![]() |
This example illustrates that stages are not strictly sequential - for example, persistent storage (Stage C) is accessed several times throughout the process. |
The following sequence of events (or workflow) occurs:
Stage A
The DocBook XML source module is checked out of the SCM by the writer. The writer edits the document using the Emacs editor with PSGML and nXML mode addons. The writer thens checks the module back into SCM, requesting an editorial review.
Stage B
The editor checks out the revised document module, proofreading and validating the updated DocBook XML source.
Stage C
The editor checks the revised DocBook XML source module back into CVS and closes the Bugzilla tickets.
Stage D
The DocBook XML source is converted into valid HTML and is posted on the website as a set of web pages, complete with table of contents and an index. An updated PDF file is also generated and posted to the website for downloading.