Just Xsl

by Simpson, John E.

• ISBN13: 9780130603111
• ISBN10: 0130603112
• Edition: 1st
• Format: Paperback
• Copyright: 2002-01-01
• Publisher: Prentice Hall

Summary

Just XSL is a clear, thorough, hands-on tutorial on using three closely related Extensible Stylesheet Language (XSL) technologies: XPath for navigating XML documents, XSL Transformations (XSLT) for transforming XML documents, and XSL Formatting Objects (XSL-FO) for rendering their content. John Simpson -- author of the best-selling Just XML -- teaches application developers and content specialists all the techniques they need to be effective with XSL -- fast. He teaches XPath, XSLT, XSL-FO by way of a complete, easy-to-use sample XML application -- the FlixML language for building movie reviews. Just XSL covers both client-side and server-side technologies. Every chapter of this breezy, informal book includes a complete example that illustrates the key techniques covered. For all Web developers familiar with the basics of XML. Since this book covers XSL-FO, it will be among the few XSL books that will be well suited for developers of print and publishing applications. No programming experience or knowledge is required.

Author Biography

John E. Simpson is a Distributed Systems Specialist with the City of Tallahassee, Florida, developing database and Web applications for the Public Works Department

Table of Contents

Preface	xv
Part 1 Introduction to XSL	1	(14)
Why XSL?	3	(12)
Enter XSL	4	(2)
The split: One spec becomes two	5	(1)
Transforming XML	6	(3)
Formatting XML	9	(3)
Styling of non-element content	9	(1)
Reordering content	10	(1)
Web-bound display	10	(1)
Is CSS good for anything XML-related?	11	(1)
XML. B Movies. Together at Last	12	(3)
Why B movies?	12	(1)
Why FlixML?	13	(2)
Part 2 XSL Transformations: XSLT	15	(392)
The ``What'' of XSLT	17	(68)
What XSLT Is Not	17	(1)
What XSLT Is	18	(1)
The formal answer	18	(1)
...and the less formal answer	19	(1)
Basic XSLT Terminology	19	(6)
Source and result trees	20	(1)
Top-level elements and instructions	20	(2)
Templates	22	(1)
Side-effect-free processing	23	(2)
XSLT and Namespaces	25	(3)
What you must do with namespaces in a stylesheet	27	(1)
XPath	28	(51)
Expressions	29	(1)
Location paths and location steps	30	(2)
Criss Cross's FlixML Review	32	(5)
The nodes that XPath knows	37	(3)
Node-sets	40	(2)
Position and context	42	(1)
Full location step syntax	43	(19)
XPath functions	62	(17)
How Do I...Find anything in an XML document, anywhere, using XPath?	79	(6)
General guidelines	80	(2)
Flights of fancy: Winging around the Criss Cross review	82	(3)
XSLT Stylesheet Basics	85	(64)
Laying the Foundation	85	(12)
Linking a stylesheet to an XML document	85	(4)
Role of the processor	89	(8)
XSLT Stylesheet Structure	97	(11)
The xsl:stylesheet element (revisited)	98	(6)
Categories of top-level elements	104	(1)
Instructions	105	(3)
Instantiating Result-Tree Content: Templates 101	108	(33)
Caged Heat's FlixML review	109	(4)
Locating source-tree ``triggers'' with xsl:template	113	(4)
Transfering source to result tree with xsl:value-of	117	(2)
Literal result elements	119	(2)
Invoking template rules with xsl:apply-templates	121	(7)
Attribute value templates	128	(2)
Template modes	130	(2)
Built-in template rules	132	(9)
How Do I...Generate entity references and other markup in the result tree?	141	(1)
``Looping''	142	(7)
Instantiating occurring content with xsl:for-each	142	(7)
Journeyman XSLT	149	(76)
Conditional Processing	149	(7)
One condition: xsl:if	150	(3)
Multiple conditions:xsl:choose	153	(3)
Instantiating Explicit Node Types	156	(19)
Using xsl:element	156	(4)
Using xsl:attribute	160	(3)
Using xsl:comment	163	(4)
Using xsl:processing-instruction	167	(1)
Using xsl:text	168	(7)
Reusing Stylesheet Content	175	(28)
Variables	175	(9)
Parameters	184	(5)
Named templates	189	(10)
Named attribute sets	199	(4)
Sorting Content	203	(7)
Controlling the Result Tree's Form/Type	210	(9)
xsl:output	211	(8)
Controlling Whitespace in the Source Tree	219	(4)
xsl:strip-space and xsl:preserve-space	219	(4)
How Do I...Link to more than one stylesheet for multiple output devices?	223	(2)
XSLT Functions	225	(72)
Processing Multiple Source Documents	226	(9)
Why more than one source document?	226	(3)
The XSLT document() function	229	(6)
Using Keys	235	(11)
Drawbacks to using ID-type attributes	235	(1)
Assigning a key with xsl:key	236	(1)
Retrieving nodes with a given key: The key () function	237	(7)
Keying an external document	244	(2)
Numbering	246	(32)
Departing from the norm	246	(6)
Formatting numbers with (surprise!) format-number()	252	(10)
Numbering lists	262	(16)
Miscellaneous Built-In Functions	278	(9)
The current () function	278	(1)
The unparsed-entity-uri () function	279	(3)
Creating unique identifiers: generate-id ()	282	(3)
The system-property () function	285	(2)
Extension Functions	287	(6)
Saxon 6.2: The line-number () function	288	(2)
The node-set () function	290	(3)
How Do I...Drive an XSLT transformation from an XML-based configuration file?	293	(4)
Beyond the Pale: Advanced XSLT	297	(58)
Including and Importing Other Stylesheets	297	(15)
Modularized code	298	(1)
When Dinosaurs Ruled the Earth's FlixML review	299	(3)
Including other stylesheets with xsl:include	302	(5)
Overriding included content with xsl:import	307	(5)
include or import: Which one to use?	312	(1)
Copying	312	(9)
Why copy?	313	(1)
Skin-deep copies: xsl:copy	314	(3)
Profound copies: xsl:copy-of	317	(3)
The ``identity transform''	320	(1)
How Do I... ``Re-version'' a document to a newer structure/DTD?	321	(2)
Source tree considerations	321	(1)
Result tree considerations	322	(1)
XSLT considerations	322	(1)
Messaging	323	(2)
The xsl:message element	323	(2)
Fallback Processing	325	(2)
Falling back with element-and function-available ()	326	(1)
``Advanced XSLT'' #1: Table Structures	327	(4)
``Advanced XSLT'' #2: Grouping	331	(9)
``Advanced XSLT'' #3: Validating	340	(6)
The Schematron language	342	(1)
Creating and running a Schematron ``validation''	343	(3)
How Do I... Transform a document for use with the Open eBook standard?	346	(1)
The package file	346	(3)
``Publishing'' an OEB publication	349	(6)
Getting There: XSLT Software	355	(40)
Client-Side XSLT	357	(28)
XPath utilities	358	(7)
XSLT editors/authoring tools	365	(11)
XSLT processors	376	(5)
Web browser support for XSLT	381	(4)
Server-Side XSLT	385	(4)
XML-to-XHTML with Microsoft Active Server Pages	386	(1)
XML-to-XHTML with Apache Cocoon	387	(2)
How Do I... Use XSLT with a database?	389	(6)
General principles	389	(1)
Database connectors	390	(1)
From database to XSLT, via ESQL	391	(4)
Just Around the Corner: Future XSLT	395	(12)
XSLT 1.1: Taking in the Seams	396	(4)
Upward compatibility	397	(1)
Portable extension functions	397	(1)
Multiple output documents	398	(1)
Automatic RTF to node-set conversion	399	(1)
XML Base support	399	(1)
XSLT 2.0: The Broader Future	400	(7)
What XSLT 2.0 ``MUST'' do	401	(3)
A clutch of ``SHOULDs'' and ``COULDs''	404	(3)
Part 3 XSL Formatting Objects	407	(150)
The ``What'' of XSL-FO	409	(40)
First, The ``Why''	410	(4)
The alternatives	410	(4)
Key XSL-FO Concepts	414	(5)
What XSL-FO is	414	(3)
Namespaces and XSL-FO	417	(1)
No ``hand-editing'' of XSL-FO documents	417	(1)
The fo:root element	418	(1)
The XSL-FO Formatting Model	419	(9)
XSL-FO's view of a publication	419	(1)
Simple page masters	420	(3)
Page sequence masters	423	(1)
Page sequences	424	(1)
Bottom line	425	(1)
Formatting objects and properties	426	(2)
Transforming to an XSL-FO Document	428	(8)
Johnny Guitar's FlixML review	429	(4)
Creating the basic result tree	433	(3)
Viewing an XSL-FO Document	436	(2)
Generate the XSL-FO document	436	(1)
Convert the XSL-FO to PDF	436	(1)
What I'll use	437	(1)
Other Regions	438	(11)
Adding a header: region-before	440	(9)
Getting the Word Out: XSL-FO Basics	449	(62)
Area Trees, Area Models	450	(4)
Area trees	450	(4)
Introduction to Formatting Objects	454	(24)
Formatting objects classified by purpose	454	(24)
Inline-Type FOs Revisited	478	(10)
Using fo:character	479	(2)
Pulling in non-XSL-FO content	481	(4)
Creating leaders	485	(1)
XSL-FO document page numbers	486	(2)
How Do I... Create a basic table of contents using XSL-FO?	488	(4)
Define the page masters	489	(1)
Establish page sequence masters	489	(1)
Build the title/table of contents page	490	(2)
Build the document itself	492	(1)
Check Your Results	492	(2)
Table-Type FOs Revisited	494	(17)
Basic tables	495	(4)
Building a basic table: An example	499	(4)
Tables with optional components	503	(8)
Advanced XSL-FO	511	(22)
XSL-FO Functions	511	(7)
XSL-FO expressions	512	(1)
Numeric functions	513	(2)
Color functions	515	(2)
Font functions	517	(1)
Aural Stylesheets	518	(1)
Writing Modes and Internationalization	519	(1)
How Do I...Create a B-movie festival ``playbill'' from a FlixML review?	520	(13)
Layout of the playbill	520	(2)
Little bits of code	522	(2)
Creating a watermark	524	(1)
Using leader dots with justified text	525	(3)
Building a document with different left-and right-page layouts	528	(5)
XSL-FO Software	533	(24)
Converting XSL-FO to PDF	535	(10)
A big deal: Inside a PDF document	535	(1)
The Apache Project: FOP	536	(6)
Render X's Xep	542	(3)
Native XSL-FO ``Viewers''	545	(12)
Why not PDF?	545	(3)
Antenna House's XSL Formatter	548	(4)
X-Smiles	552	(5)
Epilogue	557	(2)
Appendices	559	(24)
Appendix A	561	(10)
Appendix B	571	(6)
Appendix C	577	(6)
Index	583

Excerpts

PrefaceSo you're wandering among the shelves of your favorite local or on-line bookstore, looking for a book on the Extensible Stylesheet Language (XSL). These are some things you know about yourself:First, you already know the Extensible Markup Language (XML) itself. You know that it's a lightweight descendant of the Standardized General Markup Language (SGML), and that it isn't just a single markup language, despite the name, but a standard for creating and managing markup languages. You know that an XML document consists of nothing but text. You know that XML is something like HTML--all those screwy angle brackets, ampersands, and so on--but that it's also something quite a bit more. You know that in XML, the tags that define elements must be either balanced (in start tag/end tag pairs) or empty. Maybe you sometimes get confused whether "DTD" stands for "Document Type Definition" or "Document Type Declaration," but there's no doubt in your mind at all what a DTD does. And so on.Second, although you know XML at some level, you're still a little puzzled. It all seems so?so inert. What do you do with your documents and data once you've got them locked up inside XML markup? You've heard of XSL (well, you're shopping for a book about it, aren't you?), and you think maybe an answer to the question of what to do with XML might be somehow wrapped up with XSL.And third--most importantly--you want a book about XSL that helps you understand the topic, one that doesn't simply churn out a restatement (however lucid) of the spec's finer points. Sure, you want to be able to refer to the book from time to time once you've learned the subject. But long before you need to refresh your memory, you need to load all that stuff into your memory in the first place. Welcome to Just XSLIf the description of you in the three preceding paragraphs rings true, I think you're in the right place. Here's what I propose to do (and not to do) in the chapters which follow: What Just XSL DoesYou'll find one introductory chapter laying the groundwork for all that follows. If you've been nosing around XSL for a little while on your own, you can probably skim some or most of the material in this chapter.After that first chapter, which pretty much stands on its own, the book is broken up into two main parts, the first on XSL Transformations (XSLT) and the second on XSL Formatting Objects (XSL-FO). In each main section, you'll encounter a carefully organized explanation of the relevant standards from the World Wide Web Consortium, or W3C. If something in the standard is ambiguous, confusing, or outright mysterious, I'll say so. But by far, to understand most of this stuff you just need a little patience and a certain amount of guidance. I'll provide the guidance, in the form of explanations, examples, and metaphors. (As for the patience, well, you're on your own there.)Each chapter in the two main sections of the book includes (in addition to numerous fragmentary examples) a single worked sample problem, cast in the form of the answer to a "How do I??" question. The question in a given chapter may be fairly simple to answer (although the answer may be non-obvious!). Or it may be rather more complex, requiring a few pages of XSLT/XSL-FO code to answer really well.The first main section of the book, on XSLT, presented me with one potential problem that the second section didn't face. As you will see, effective use of XSLT is highly dependent on effective use of the XPath standard. It was pretty safe to assume that when you came to Just XSL, you'd already know enough about XML; it wasn't as safe, though, to make the same assumption about your knowledge of XPath. So the first chapter of the XSLT section details use of XPath as well.Finally, I'll also demonstrate and explain the basics of some of the more popular software tools for processing