webgen 0.5.7 → 0.5.8

data/data/webgen/{website_styles → website_bundles/style}/andreas06/src/default.css

@@ -259,7 +259,7 @@ margin: 0px;
 padding: 0px;
 }
 
-.nav, #leftside #submenu ul a {
+.nav, #leftside #submenu ul a, #leftside #submenu ul span {
 color:#d04a10;
 display:block;
 font-size:1.1em;
@@ -271,20 +271,22 @@ text-decoration:none;
 width:125px;
 }
 
-.nav:hover, #leftside #submenu ul a:hover {
+.nav:hover, #leftside #submenu ul a:hover, #leftside #submenu ul span:hover,
+#leftside #submenu ul li.webgen-menu-item-selected a, #leftside #submenu ul li.webgen-menu-item-selected span {
 border:1px solid #fa9035;
 color:#505050;
 padding:1px 1px 1px 9px;
 }
 
-.sub, #leftside #submenu ul ul a {
+.sub, #leftside #submenu ul ul a, #leftside #submenu ul ul span {
 font-size:0.9em;
 margin-left:20px;
 padding:1px 1px 1px 6px;
 width:105px;
 }
 
-.sub:hover, #leftside #submenu ul ul a {
+.sub:hover, #leftside #submenu ul ul a:hover, #leftside #submenu ul ul span:hover,
+#leftside #submenu ul ul li.webgen-menu-item-selected a, #leftside #submenu ul ul li.webgen-menu-item-selected span {
 border:1px solid #fa9035;
 color:#505050;
 padding:0 0 0 5px;

data/data/webgen/{website_styles → website_bundles/style}/andreas06/src/default.template

@@ -37,8 +37,8 @@
           <div id="leftside">
             <a id="sectionmenu"></a>
             <p class="soft">Some text here, maybe a website description</p>
-            <% if node.level > 1 %>
-	    <h1>Site menu:</h1>
+            <% if context.node.level > 1 %>
+            <h1>Site menu:</h1>
             <div id="submenu">{menu: {start_level: 2, max_levels: 2}}</div>
 	    <% end %>
           </div>

data/data/webgen/website_skeleton/README

@@ -5,6 +5,6 @@ description:
   When using the standard settings, the sources are in the directory `src` and
   the generated output goes into `out`. Extensions can be placed under `ext`.
 
-  For configuration purposes, use the config.rb or config.yaml files.
+  For configuration purposes, use the config.yaml file.
 ---
 note: This file can be deleted!

data/data/webgen/website_skeleton/config.yaml

@@ -10,8 +10,9 @@
 #
 # Have a look at the documentation of the individual configuration options to see
 # the allowed format of the values. Since this is a YAML file, you can easily set
-# configuration options to strings, integers, dates, arrays, hashes and more.
+# configuration options as strings, integers, dates, arrays, hashes and more.
 #
-# The available configuration options can be listed using the `webgen config`
-# command, for example: `webgen config sourcehandler` will list all options starting
-# with sourcehandler.
+# The available configuration options can be found on the homepage in the
+# Configuration Option Reference at
+#
+#     http://webgen.rubyforge.org/documentation/reference_configuration.html

data/doc/contentprocessor/blocks.page

@@ -8,26 +8,59 @@ templates to define the place where the actual page content should be.
 
 The general syntax is as follows:
 
-    <webgen:block name='BLOCK_NAME' chain='(L)CN;(L)CN;...' node='first' notfound='ignore' />
+    <webgen:block name='BLOCK_NAME' chain='(L)CN;(L)CN;...' node='next|first|current' notfound='ignore' />
 
 So it is basically an XML tag with the mandatory attribute `name` and the optional attributes
-`chain`, `node` and `notfound`:
+`chain`, `node` and `notfound`. The attributes are explained below but first comes a small
+explanation of how this tag works.
+
+webgen uses a node chain when rendering a page file. The default node chain is automatically
+determined via the `template` meta information (see [SourceHandler::Template]({relocatable:
+../sourcehandler/template.html})) and the important thing to keep in mind is that the first node in
+the node chain is always the currently rendered template/page.
+
+For example, consider a `default.template` with a block tag of `<webgen:block name='content' />` and
+an `index.page` that should be rendered. This would result in a node chain of (note that the CN of a
+page file has the extension `html`)
+
+    default.template ---> index.html
+
+During the rendering of the `index.page`, the node chain like shown above is created and rendering
+is started at the *first* node in the chain, in this case at `default.template`. When the block tag
+is encountered, it is replaced by the block named `content`, after rendering it according to its
+render pipeline, of the `index.page`. If such a block tag was not in the template, then the content
+of the `index.page` file would never be inserted into the output file! The behaviour of the block
+tag can be customized by using the various attributes.
+
+Summing up: the `template` meta information is used to create a node chain which is then used by the
+block tag to render the appropriate blocks.
+
+Following is the documentation for the available attributes of the tag:
 
 * The `name` attribute is the only mandatory attribute and it specifies the name of the block that
-  should be rendered in place of the block tag. The next node in the used node chain (if there is
-  only one node left in the node chain that node is used) needs to have a block that has such a name
-  (this behaviour can be changed with the `node` attribute), otherwise an error is raised. The
-  block is rendered according to its render pipeline and then inserted.
+  should be rendered in place of the block tag. If the used node (see the `node` attribute) has no
+  such named block, an error is raised.
 
 * The optional attribute `chain` specifies the node chain that should be used for rendering the
   block. Its value needs to be a list of (localized) canonical names of nodes separated by
   semicolons that should be used as node chain. If this attribute is not specified the default node
   chain is used.
 
-* The optional attribute `node` specifies which node in the node chain should be used. If this
-  attribute is not specified, the next node in the node chain is used. If it is specified with the
-  value `first`, then the node chain is traversed till a node is found that has a block with the
-  specified name. If no such node is in the node chain, an error is raised.
+* The optional attribute `node` specifies which node in the node chain should be used.
+
+  * If this attribute is not specified or its value is `next`, the next node in the node chain (i.e.
+    the second node) is used. If there is only one node left in the node chain that node is used.
+
+  * If the attribute has a value of `first`, then the node chain is traversed till a node is found
+    that has a block with the specified name. If no such node is in the node chain, an error is
+    raised. If the attribute `chain` is also used, then the search starts at the first node of the
+    node chain. Otherwise it starts at the second node.
+
+  * If the attribute has a value of `current`, the currently processed node is used (i.e. the first
+    node in the node chain).
+
+    > Note that the attribute `chain` is not used in this situation!
+    {.important}
 
 * If the optional attribute `notfound` has a value of `ignore`, all errors that can occur are
   ignored. This is especially useful when used in templates to include blocks that may not be

data/doc/contentprocessor/builder.page

@@ -52,7 +52,7 @@ a custom XML document (the `content` block has to be valid Ruby!):
     title: Person Object
     template: ~
     --- pipeline:builder
-    xml.persons(:path => node.absolute_lcn) do |p|
+    xml.persons(:path => context.node.absolute_lcn) do |p|
       p.person do |b|
         b.firstname('Thomas')
         b.lastname('Leitner')

data/doc/contentprocessor/erb.page

@@ -7,19 +7,20 @@ This processer uses ERB (embedded Ruby) to process content. For detailed informa
 a look at its documentation by executing `ri ERB` or the [ruby documentation
 site](http://www.ruby-doc.org/)!
 
-You can use the following special objects in your ERB code:
+You can use the special object `context` in your ERB code which provides the whole rendering context
+and the following useful methods:
 
-* `context`: This object provides the whole rendering context, the following objects are just for
-  backwards compatibility.
+* `website`: Provides access to the `Webgen::Website` object which can be used to access all aspects
+  of the currently rendered website.
 
-* `ref_node` (or `context.ref_node`): The reference node which is the source of the ERB code that is
-  executed. Should be used, for example, for resolving paths.
+* `node` (or `content_node`): The node that gets currently rendered. Should be used for retrieving
+  meta information.
 
-* `node` (or `context.content_node`): The node that gets currently rendered. Should be used for
-  retrieving meta information.
+* `ref_node`: The reference node which is the source of the ERB code that is executed. Should be
+  used, for example, for resolving paths.
 
-* `dest_node` (or `context.dest_node`): The node in which the result gets inserted. Should be used
-  for calculating relative paths.
+* `dest_node`: The node in which the result gets inserted. Should be used for calculating relative
+  paths.
 
 Here is a small usage example. The following put in a page file
 
@@ -29,7 +30,7 @@ Here is a small usage example. The following put in a page file
     <%% end %>
 
     Outputting all meta information:
-    <%% node.meta_info.each do |k,v| %>
+    <%% context.node.meta_info.each do |k,v| %>
       * <%%= k %> = <%%= v %>
     <%% end %>
 
@@ -41,7 +42,7 @@ Here is a small usage example. The following put in a page file
     <% end %>
 
     Outputting all meta information:
-    <% node.meta_info.each do |k,v| %>
+    <% context.node.meta_info.each do |k,v| %>
       * <%= k %> = <%= v %>
     <% end %>
 

data/doc/contentprocessor/redcloth.page

@@ -12,6 +12,8 @@ RedCloth library. For detailed information about Textile have a look at the [Tex
 >     gem install RedCloth
 {.warning}
 
+You can use the configuration option `contentprocessor.redcloth.hard_breaks` to enable/disable the
+conversion of single newlines into HTML break tags.
 
 Example
 -------
@@ -36,4 +38,4 @@ Here is a short sample of a text in Textile markup:
 
 
 [1]: http://hobix.com/textile/
-[2]: http://whytheluckystiff.net/ruby/redcloth/
+[2]: http://whytheluckystiff.net/ruby/redcloth/

data/doc/extensions.page

@@ -6,11 +6,11 @@ title: Extensions
 Following is a listing of all available extensions:
 
 <%
-pattern = /#{File.join(node.parent.absolute_lcn, '/')}(contentprocessor|output|source|sourcehandler|tag|)\/.*html$/
-context.content_node.tree.node_access[:alcn].select {|alcn, n| alcn =~ pattern}.sort.each do |alcn, n|
+pattern = /#{File.join(context.node.parent.absolute_lcn, '/')}(contentprocessor|output|source|sourcehandler|tag|)\/.*html$/
+context.node.tree.node_access[:alcn].select {|alcn, n| alcn =~ pattern}.sort.each do |alcn, n|
 next if n.is_fragment?
 %>
-* <%= dest_node.link_to(n) %>
+* <%= context.dest_node.link_to(n) %>
 <%
 end
 %>

data/doc/faq.page

@@ -10,14 +10,17 @@ title: FAQ
 
 *   **Why can I specify multiple blocks in a page/template file?**
 
-    This allows you to provide different content parts for one page. For example, image you have a
+    This allows you to provide different content parts for one page. For example, imagine you have a
     layout with a sidebar and you want to have page specific sidebar contents. The easiest way to
     achieve that is to add a `sidebar` block to the page files that provide a page specific sidebar
-    content and conditionally include the `sidebar` block in your `default.template`, like this:
+    content and include the `sidebar` block in your `default.template`, like this:
 
-        <%% if node.node_info[:page].blocks.has_key?('sidebar') %>
-          \<webgen:block name='sidebar' />
-        <%% end %>
+        <webgen:block name='sidebar' notfound="ignore" chain="first" />
+
+    By using `notfound="ignore"` we tell webgen to ignore errors when such a block is not found and
+    the `chain="first"` attribute tells webgen to search through the whole node chain for such a
+    block. The latter is needed when nested templates are used because by default only the next node
+    in the chain is inspected.
 
 *   **What do I have to do to use the extensions?**
 
@@ -43,9 +46,9 @@ questions.
 
 Use the `webgen` command to create the needed directories
 
-    webgen create -t project -s andreas07 my_site
+    webgen create -b default -b andreas07 my_site
 
-This will create a webgen website in the directory `my_site` using the specified template and style.
+This will create a webgen website in the directory `my_site` using the specified bundles.
 
 ### ... set configuration options?
 
@@ -176,7 +179,7 @@ There are many ways to accomplish this, I will show only one way here using bloc
 following to the sidebar part in your `default.template` (ensure that you haven't disabled `erb` in
 the processing pipeline):
 
-    <%% if node.node_info[:page].blocks.has_key?('sidebar') %>
+    <%% if context.node.node_info[:page].blocks.has_key?('sidebar') %>
       <webgen:block name='sidebar' />
     <%% end %>
 
@@ -208,8 +211,8 @@ having menu entries that point to the same page and links to external pages.
 
 ### ... use short menu title?
 
-You can use a special of the meta information `link_attrs` to achieve that. Just use the following
-in the meta information block of the page file for which you want a short menu title:
+You can use the special meta information key `link_attrs` to achieve that. Just use the following in
+the meta information block of the page file for which you want a short menu title:
 
     link_attrs:
       :link_text: Short title

data/doc/getting_started.page

@@ -21,21 +21,18 @@ The directory in which these directories are in is called the *website directory
 
 Don't worry too much about these directories since webgen is able to create the correct directory
 structure for you. By running the command `webgen create sample_site`, the website directory
-`sample_site` is created with the default website template and website style. You can naturally use
-any available template or style by passing their names to the respective options of the `create`
-command.
-
-> A *website template* provides a starting point for your website. For example, the `project`
-> template defines several pages including a features and about page.
->
-> A *website style* defines the look and feel of your website. webgen comes with many predefined
-> styles (nearly all of them are converted open source web design styles).
+`sample_site` is created with the default website bundles applied. You can naturally use any
+available bundles by passing their names to the `-b` option of the `create` command.
+
+> A *website bundle* defines some starting content for a website. The `default` bundle defines just
+> a sample content file sothat some output can be viewed after webgen is run. All other bundles are
+> style bundles which define the look and feel of your website. webgen comes with many predefined
+> style bundles and nearly all of them are converted open source web design styles.
 {.information}
 
-Don't worry if you don't like the used website style - you can easily change it later. Have a look
-at [the examples section](0.4.x/examples/website_styles/index.html) (note: these are still the
-example from the previous version of webgen but the styles haven't changed) to see demonstrations
-for all shipped website templates and styles!
+Don't worry if you don't like the used website style - you can easily change it later using the
+`webgen apply` command. Have a look at the [Website Styles Reference]({relocatable:
+reference_website_styles.html}) to see demonstrations for all shipped website templates and styles!
 
 Since the basic parts are now in place, you can generate the HTML files. There are two
 possibilities:
@@ -47,11 +44,11 @@ possibilities:
 
 Easy! webgen has used all files in the `src` directory and created the HTML output in the directory
 `out`. Now you just need to open the `out/index.html` file to view your website! However, as we did
-not write any content yet, there is not much to see (only the default pages). So let's do that now!
+not write any content yet, there is not much to see (only the default page). So let's do that now!
 
 > Since webgen automatically creates relative links, you will have a fully functional website
 > without needing a web server! This also implies that you can deploy your website to any directory
-> on your web server and it will just work!
+> on your web server and it will *just work*!
 {.information}
 
 

data/doc/index.page

@@ -7,7 +7,9 @@ This documentation is for the *repository version*{: style='color: red; font-wei
 webgen and therefore may state features that are not available in the latest released version.
 
 * The documentation for the *latest released 0.5.x*{: style='color: red; font-weight: bold'} version
-  can be found [here](http://webgen.rubyforge.org/documentation/0.5.x/index.html)
+  can be found [here](http://webgen.rubyforge.org/documentation/0.5.x/index.html). This
+  documentation can also be generated locally by running `rake htmldoc` in the root directory of the
+  weben distribution.
 
 * If you are looking for the documentation of the *0.4.x*{: style='color: red; font-weight: bold'}
   series, it can be found [here](http://webgen.rubyforge.org/documentation/0.4.x/index.html).
@@ -58,6 +60,10 @@ Following is a list of all the reference documentation of webgen:
 * [**Configuration Options Reference**]({relocatable: reference_configuration.html}): Overview of all
   configuration options.
 
+* [**Website Styles Reference**]({relocatable: reference_website_styles.html}): Previews of all
+  website styles that ship with webgen.
+
+
 # Developer Documentation
 
 webgen makes it easy to extend its functionality by writing simple extension classes. All

data/doc/manual.page

@@ -12,7 +12,7 @@ webgen website is structured and how content can be added and so on.
 
 
 
-# The `webgen` command
+# The `webgen` command {#cli}
 
 The executable for webgen is called... webgen ;-) It uses a command style syntax (like Subversion's
 `svn` or Rubygem's `gem` commands) through the [cmdparse] library. To get an overview of the
@@ -20,7 +20,8 @@ possible commands run `webgen help`.
 
 The main command is the `render` command which does the actual website generation. This command uses
 either the environment variable `WEBGEN_WEBSITE` (if it is set and non-empty) or the current working
-directory as website directory if none was specified via the gloabl `-d` option.
+directory as website directory if none was specified via the gloabl `-d` option. All other commands
+that need a valid webgen website directory specified work in the same way.
 
 You can invoke a command by specifying its name after the executable name. Also counting the
 executable `webgen` as a command, the options for a command are specified directly after the command
@@ -35,10 +36,29 @@ valid:
 
 Following is a short overview of the available commands:
 
-*   `create [-t TEMPLATE] [-s STYLE] SITE_DIR`
+*   `apply [-f] (BUNDLE_NAME|BUNDLE_URL)`
 
-    Creates a basic webgen website in `SITE_DIR` using the optional template and styles. All
-    available templates and styles are listed in the help output for the command.
+    The argument may either be a valid bundle name or an URL to a bundle archive (a (gzipped) tar
+    archive). The command applies the bundle to the given webgen website. The files that will be
+    written to website directory are shown and the user is asked to confirm that the shown files
+    should indeed be written (and sometimes overwritten). If the `-f` option is used, the files are
+    always written.
+
+    You can get the full list of available bundle names by running `webgen help apply`!
+
+*   `create [-b BUNDLE] SITE_DIR`
+
+    Creates a basic webgen website in `SITE_DIR` using the optionally specified bundles. The option
+    `-b` can be used more than once to specify more than one bundle - the bundles are applied in the
+    order they are specified. As with the `apply` command, `BUNDLE` may either be a valid bundle
+    name or a bundle URL.
+
+    > If you don't specify the `-b` option, the default value is used which applies the `default`
+    > and the `style-andreas07` bundles. The former only creates a simple `src/index.page` sothat
+    > some output can be seen and the latter applies a nice layout.
+    {.information}
+
+    All available bundles are listed in the help output for the command.
 
 *   `help`
 
@@ -74,11 +94,11 @@ files and directories under this directory:
 
 * `src`: The source directory in which all the source files for the website are. If this directory
   should not be called `src` or you want to include additional source directories, you need to
-  change the `sources` configuration option.
+  change the [`sources` configuration option]({relocatable: reference_configuration.html#sources}).
 
 * `out`: This directory is created, if it does not exist, when webgen generates the HTML files. All
   the output files are put into this directory. The name of this directory can be changed by setting
-  the `output` configuration option.
+  the [`output` configuration option]({relocatable: reference_configuration.html#output}).
 
 * `ext`: The extension directory (optional). You can put self-written extensions into this directory
   so that they are used by webgen. See the [extension directory]({relocatable: '#website-ext'})
@@ -224,9 +244,10 @@ SourceHandler::Template as they are responsible for handling these page and temp
 You can naturally use any other type of file. However, be aware that some files may not be processed
 by webgen when no source handler class for them exists. For example, there is currently no source
 handler class for `.svg` files, so those files would be ignored. If you just want to have files
-copied from a source to the output directory (like images or CSS files), the SourceHandler::Copy
-class is what you need! Look through the documentation of the [availabe source handler
-classes]({relocatable: extensions.html}) to get a feeling of what files are handled by webgen.
+copied from a source to the output directory (like images or CSS files), the
+[SourceHandler::Copy]({relocatable: sourcehandler/copy.html}) class is what you need! Look through
+the documentation of the [availabe source handler classes]({relocatable: extensions.html}) to get a
+feeling of what files are handled by webgen.
 
 
 ## Source Paths Naming Convention {#source-naming}
@@ -289,25 +310,50 @@ the same canonical name.
 ## Canonical Name of a File ### {#source-cn}
 
 webgen provides the functionality to define the same content in more than one language, ie. to
-localize content. This is achieved with the _canonical name_ of a path.
+localize content. This is achieved with the _canonical name_ of a path, short CN.
 
 When multiple paths share the same canonical name, webgen assumes that they have the same content
-but in different languages. It is also possible to specify a _language independent_ path which is
-used as a fallback. Therefore when a path should be resolved using a canonical name and a given
-language, it is first tried to get the path in the requested language. If this is not possible
-(ie. no such localization exists), the unlocalized path is returned if it exists.
+but in different languages. It is also possible to specify a _language independent_ path (i.e. one
+without a language) which is used as a fallback. Therefore when a path should be resolved using a
+canonical name and a given language, it is first tried to get the path in the requested language. If
+this is not possible (ie. no such localization exists), the unlocalized path is returned if it
+exists.
+
+For example, assume that we have the following `src` directory:
+
+    /test.jpg
+    /images/my.jpg
+    /images/my.de.jpg
+    /index.page
+    /index.fr.page
+    /index.de.page
+
+Since the path `images/my.jpg` has no language part, it is assumed to be unlocalized. In contrast,
+`images/my.de.jpg` has the "same" picture but in a German version. So, when specifying
+`images/my.jpg` in `index.de.page`, the correct localized version will be returned, i.e.
+`images/my.de.jpg`. When specifying `images/my.jpg` in `index.page` or in `index.fr.page`, the
+unlocalized version will be returned since no localized version exists.
 
 > Directories and fragments are never localized, only files are!
 {.important}
 
-It is also possible to use the _localized canonical name_ of a path to resolve it. The localized
-canonical name is the same as the canonical name but with a language code inserted before the
-extension. If the localized canonical name is used to resolve a path, a possibly additionally
+It is also possible to use the _localized canonical name_ of a path (short: LCN) to resolve it. The
+localized canonical name is the same as the canonical name but with a language code inserted before
+the extension. If the localized canonical name is used to resolve a path, a possibly additionally
 specified language is ignored as it is assumed that the user really only wants the path in the
 specified language!
 
-This also means that all paths are not resolved using their real source or output names but using
-the (localized) canonical name! This is different from previous webgen versions!
+Continuing the above example, this means that `images/my.de.jpg` is always returned when one
+specifies `images/my.de.jpg` in any of the index page files, e.g. in `index.fr.page`.
+
+Both canonical and localized canonical names can be absolute (ACN and ALCN) which is done by using
+the full path starting with a slash. This is especially useful when you don't exactly know in which
+hierarchy level a certain canoncial name gets evaluated.
+
+Everything said above also means that all paths are not resolved using their real source or output
+names but using the (localized) canonical name! So when specifying paths for extensions, for example
+when using the [relocatable tag]({relocatable: tag/relocatable.html}), you always have to use the
+(absolute) (localized) canonical names. This is different from previous webgen versions!
 
 
 ## Output Path Name Construction ### {#source-output}
@@ -417,14 +463,17 @@ Here are some example path patterns:
 
 Following is the list of rules how source files are handled by webgen:
 
-* All path names of all sources specified in the configuration option `sources` are fetched. Prior
-  listed sources have priority over later listed sources if both specify the same path.
+* All path names of all sources specified in the configuration option [`sources`]({relocatable:
+  reference_configuration.html#sources}) are fetched. Prior listed sources have priority over later
+  listed sources if both specify the same path.
 
-* Those paths which match a pattern of the configuration option `sourcehandler.ignore` are excluded.
+* Those paths which match a pattern of the configuration option
+  [`sourcehandler.ignore`]({relocatable: reference_configuration.html#sourcehandlerignore}) are excluded.
 
 * The source handler classes are invoked according to the invocation order specified in
-  `sourcehandler.invoke` and they use only those paths that match one of their path patterns
-  specified in `sourcehandler.patterns`.
+  [`sourcehandler.invoke`]({relocatable: reference_configuration.html#sourcehandlerinvoke}) and
+  they use only those paths that match one of their path patterns specified in
+  [`sourcehandler.patterns`]({relocatable: reference_configuration.html#sourcehandlerpatterns}).
 
 As you might have deduced from the processing list above, it is possible that one path is handled by
 multiple source handlers. This can be used, for example, to render an XML file as HTML and copy it
@@ -438,13 +487,15 @@ example the title of the path, if it should appear in a menu and so on. This met
 specified in several ways, including:
 
 * Source handlers can provide default meta information for their handled paths (set using the
-  configuration option `sourcehandler.default_meta_info`)
+  configuration option [`sourcehandler.default_meta_info`]({relocatable:
+  reference_configuration.html#sourcehandlerdefault_meta_info}).
 
 * Some file types allow meta information to be specified directly in the file, for example page
   files in [Webgen Page Format]({relocatable: webgen_page_format.html}).
 
 * Meta information can also be specified in special meta information backing files. These files are
-  handled by the source handler SourceHandler::Metainfo.
+  handled by the source handler [SourceHandler::Metainfo]({relocatable:
+  sourcehandler/metainfo.html}).
 
 There is clearly defined order in which meta information is applied to a node for a path: