================================
XSLT Transformations over Movies
================================

-------------------------------------------------------------------------

 1. Return an element "movie_titles" that contains a list of
    alphabetically sorted titles of all movies in the document.

    Write two stylesheets, one where iteration is expressed by
    template calls and another one where iteration is expressed by
    <xsl:for-each> elements.
-------------------------------------------------------------------------

Version 1: Iteration by template calls


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:apply-templates select="movies"/>
</xsl:template>

<xsl:template match="movies">
  <movies>
    <xsl:apply-templates select="movie"/>
      <xsl:sort select="title"/>   
    <xsl:apply-templates/>
  </movies>
</xsl:template>

<xsl:template match="movie">
  <xsl:copy-of select="title">
</xsl:template>

</xsl:stylesheet>

-------------------------------------------------------------------------

Version 2: Iteration by  <xsl:for-each>


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:for-each select=".//title">
    <xsl:sort select="."/>   
    <xsl:copy-of select="."/>
  </xsl:for-each>
</xsl:template>

</xsl:stylesheet>



-------------------------------------------------------------------------

 2. Return an element <movies> with a list of <movie> elements,
    containing in turn attributes title and year, ordered by year in
    descending order.  Use static element and attribute constructors
-------------------------------------------------------------------------

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:apply-templates select="movies"/>
</xsl:template>

<xsl:template match="movies">
  <movies>
    <xsl:apply-templates select="movie">
      <xsl:sort select="year" data-type="number" order="descending"/>   
    </xsl:apply-templates>
  </movies>
</xsl:template>

<xsl:template match="movie">
  <movie title="{title}" year="{year}"/>
</xsl:template>

</xsl:stylesheet>




-------------------------------------------------------------------------

 3. Rewrite the preceding stylesheet so that you use copying and
    dynamic element and attribute constructors whereever possible.
-------------------------------------------------------------------------

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:apply-templates select="movies"/>
</xsl:template>

<xsl:template match="movies">
  <xsl:copy>
    <xsl:apply-templates select="movie">
      <xsl:sort select="year" data-type="number"/>   
    </xsl:apply-templates>
  </xsl:copy>
</xsl:template>

<xsl:template match="movie">
  <xsl:copy>
    <xsl:attribute name="year" select="title"/>
    <xsl:attribute name="year" select="year"/>
  </xsl:copy>
</xsl:template>

</xsl:stylesheet>




-------------------------------------------------------------------------

 4. Restructure the movies document so that 
    - movies appear according to their year, with the most recent years
      first, and, within the same year, according to their title
    - countries appear in alphabetical order
    - for each director, the first name is given before the last name
    - actors of a movie appear according to their last name and, for
      actors with the same last name, according to their first name.
    Everything else should remain as before.
-------------------------------------------------------------------------

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:apply-templates select="movies"/>
</xsl:template>

<xsl:template match="movies">
  <xsl:copy>
    <xsl:apply-templates select="movie">
      <xsl:sort select="year" data-type="number" order="descending"/>   
      <xsl:sort select="title" data-type="text" order="ascending"/>   
    </xsl:apply-templates>
  </xsl:copy>
</xsl:template>

<xsl:template match="movie">
  <xsl:copy>
    <xsl:copy-of select="title, year"/>
    <xsl:for-each select="country">
      <xsl:sort select="."/>
      <xsl:copy-of select="."/>
    </xsl:for-each>
    <xsl:copy-of select="genre, summary"/>
    <xsl:apply-templates select="director"/>
    <xsl:for-each select="actor">
      <xsl:sort select="last_name" data-type="text" order="ascending"/>
      <xsl:sort select="first_name" data-type="text" order="ascending"/>
      <xsl:copy-of select="."/>
    </xsl:for-each>
  </xsl:copy>
</xsl:template>

<xsl:template match="director">
  <xsl:copy>
    <xsl:copy-of select="first_name, last_name, birth_date"/>
  </xsl:copy>
</xsl:template>

</xsl:stylesheet>




-------------------------------------------------------------------------

 5. Return an element <countries> with an alphabetically sorted list
    of <country> elements, where each country from the document occurs
    exactly once.

    Use the two approaches shown in the lecture.
-------------------------------------------------------------------------

Version 1: XPath test for duplicates


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>


<xsl:template match="/">
  <xsl:element name="countries">
    <xsl:apply-templates select=".//country">
      <xsl:sort select="." order="ascending" data-type="text"/>
    </xsl:apply-templates>
  </xsl:element>
</xsl:template>


<xsl:template match="country">
  <xsl:if test="not(. = preceding::country)">
    <xsl:copy-of select="."/>
  </xsl:if>
</xsl:template>

</xsl:stylesheet>

-------------------------------------------------------------------------

Version 2: Muenchian approach to duplicate elimination


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:key name="countries-by-country" 
         match="country" 
         use="text()"/>

<xsl:template match="/">
  <xsl:element name="countries">
    <xsl:apply-templates select=".//country">
      <xsl:sort select="." order="ascending" data-type="text"/>
    </xsl:apply-templates>
  </xsl:element>
</xsl:template>

<xsl:template match="country">
  <xsl:if test=".[count(.| key('countries-by-country', . )[1]) = 1]">
    <xsl:copy-of select="."/>
  </xsl:if>
</xsl:template>

</xsl:stylesheet>


-------------------------------------------------------------------------

 6. Output movies (title and year) and within each movie those actors
    whose role occurs in the summary of the movie.
-------------------------------------------------------------------------

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:apply-templates select="movies"/>
</xsl:template>

<xsl:template match="movies">
  <xsl:copy>
    <xsl:apply-templates select="movie"/>
  </xsl:copy>
</xsl:template>

<xsl:template match="movie">
  <xsl:copy>
    <xsl:copy-of select="title"/>
    <xsl:copy-of select="year"/>
    <xsl:apply-templates select="actor"/>
  </xsl:copy>
</xsl:template>

<xsl:template match="actor">
  <xsl:if test="contains(../summary,role)">
    <xsl:copy-of select="."/>
  </xsl:if>
</xsl:template>

</xsl:stylesheet>



-------------------------------------------------------------------------

 7. Return an element <actors> with a list of <actor> elements,
    alphabetically sorted by last name and first name, where each
    actor from the movies document occurs exactly once. 

    Each actor element should contain last name, first name, and year
    of birth of the actor.

    Hint: You need an <xsl:variable> element to remember the last name
    when you sort according to first name.
-------------------------------------------------------------------------

The first sample solution uses the XPath-based method to eliminate duplicates:


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:element name="actors">
    <xsl:for-each select=".//actor">
      <xsl:sort select="last_name"/>
      <xsl:sort select="first_name"/>
      <xsl:variable name="fn" select="first_name"/>
      <xsl:if test="not(last_name = preceding::actor[first_name=$fn]/last_name)">
      <xsl:copy>
	<xsl:copy-of select="last_name, first_name, birth_date"/>
      </xsl:copy>
      </xsl:if>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

</xsl:stylesheet>


-------------------------------------------------------------------------

The next sample improves upon this idea by creating an index to speed
up the search for actors with the same last name.


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:key name="actor-by-last_name" match="actor" use="last_name"/>


<xsl:template match="/">
  <xsl:element name="actors">
    <xsl:for-each select="//actor">
      <xsl:sort select="last_name"/>
      <xsl:sort select="first_name"/>
      <xsl:variable name="fn" select="first_name"/>
      <xsl:if test=".[generate-id() = 
                      generate-id(key('actor-by-last_name',last_name)[first_name = $fn][1])]">
      <xsl:copy>
	<xsl:copy-of select="last_name, first_name, birth_date"/>
      </xsl:copy>
      </xsl:if>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

</xsl:stylesheet>

-------------------------------------------------------------------------

The third sample solution follows an idea of Lukas Siemon and uses a
key to choose only one copy of several duplicate actors.


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:key name="actor-by-name" match="actor" use="concat(last_name, '+', first_name)"/>


<xsl:template match="/">
  <xsl:element name="actors">
    <xsl:for-each select="//actor[generate-id() = 
                                  generate-id(key('actor-by-name',
                                                   concat(last_name, '+', first_name))[1])]">
      <xsl:sort select="last_name"/>
      <xsl:sort select="first_name"/>
      <xsl:copy>
	<xsl:copy-of select="last_name, first_name, birth_date"/>
      </xsl:copy>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

</xsl:stylesheet>





-------------------------------------------------------------------------

 8. Extend the stylesheet for the preceding task so that an actor also
    contains an element “movies” with the movies starring the actor
    (title and year are all the info needed for a movie).
-------------------------------------------------------------------------

This is an extension of the first version. Note that I introduced an
additional variable because I want to remember both the first name and
the last name when retrieving the films of an actor.



<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:template match="/">
  <xsl:element name="actors">
    <xsl:for-each select=".//actor">
      <xsl:sort select="last_name"/>
      <xsl:sort select="first_name"/>
      <xsl:variable name="fn" select="first_name"/>
      <xsl:if test="not(last_name = preceding::actor[first_name=$fn]/last_name)">
      <xsl:copy>
	<xsl:copy-of select="last_name, first_name, birth_date"/>
        <xsl:variable name="ln" select="last_name"/>
        <xsl:for-each select="//movie[actor[last_name=$ln and first_name=$fn]]">
          <xsl:copy>
  	    <xsl:copy-of select="title, year"/>
          </xsl:copy>
        </xsl:for-each>
      </xsl:copy>
      </xsl:if>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

</xsl:stylesheet>


-------------------------------------------------------------------------

This is an extension of the second version. I used an additional
variable to remember the last name when retrieving the movies for an
actor.

In line with the usage of an index ("key") for retrieving actors, I
also used an index for retrieving movies.



<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:key name="actor-by-last_name" match="actor" use="last_name"/>
<xsl:key name="movie-by-actor-last_name" match="movie" use="actor/last_name"/>


<xsl:template match="/">
  <xsl:element name="actors">
    <xsl:for-each select="//actor">
      <xsl:sort select="last_name"/>
      <xsl:sort select="first_name"/>
      <xsl:variable name="ln" select="last_name"/>
      <xsl:variable name="fn" select="first_name"/>
      <xsl:if test=".[generate-id() = 
                      generate-id(key('actor-by-last_name',last_name)[first_name = $fn][1])]">
      <xsl:copy>
	<xsl:copy-of select="last_name, first_name, birth_date"/>
        <xsl:for-each select="key('movie-by-actor-last_name', last_name)">
          <xsl:if test=".[actor[last_name=$ln and first_name=$fn]]">
            <xsl:copy>
              <xsl:copy-of select="title, year"/>
            </xsl:copy>
          </xsl:if>
        </xsl:for-each>
      </xsl:copy>
      </xsl:if>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

</xsl:stylesheet>

-------------------------------------------------------------------------

This is an extension of the third version, again following the
solution by Lukas Siemon.

Here, we use the same index for retrieving the movies as for
retrieving the actors, which makes sense, since each actor occurs
below the movie in which they act.


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0"
            encoding="iso-8859-1" indent="yes"/>

<xsl:key name="actor-by-name" match="actor" use="concat(last_name, '+', first_name)"/>


<xsl:template match="/">
  <xsl:element name="actors">
    <xsl:for-each select="//actor[generate-id() = 
                                  generate-id(key('actor-by-name',
                                                   concat(last_name, '+', first_name))[1])]">
      <xsl:sort select="last_name"/>
      <xsl:sort select="first_name"/>
      <xsl:copy>
	<xsl:copy-of select="last_name, first_name, birth_date"/>
        <xsl:for-each select="key('actor-by-name',
                                   concat(last_name, '+', first_name))/parent::movie">
          <xsl:copy>
            <xsl:copy-of select="title, year"/>
          </xsl:copy>
        </xsl:for-each>
      </xsl:copy>
    </xsl:for-each>
  </xsl:element>
</xsl:template>

</xsl:stylesheet>