webgen 0.5.17 → 1.0.0.beta1

data/doc/contentprocessor/builder.page

@@ -1,79 +0,0 @@
----
-title: Webgen::ContentProcessor::Builder
----
-## Description
-
-This content processor can be used to programatically create XHTML/XML documents
-([Reference][1]). The top builder object is provided through the `xml` object. There are also other
-objects provided by webgen available - have a look at the [erb documentation](erb.html).
-
-> This extension is only available if you have installed the [builder][1] library. The preferred way
-> to do this is via Rubygems:
->
->     gem install builder
-{:.warning}
-
-
-## Examples
-
-Here is a short sample of content that is valid Ruby and uses the special `xml` object:
-
-    xml.h1("This a h1 header", :id => 'myid')
-
-    xml.p do |p|
-      p.text! "You can just write "
-      p.b "your"
-      p.text! "paragraphs here and"
-      p.a("link", :href => "http://someurl.com")
-      p.text! "them below. This is also a"
-      p.i "nice"
-      p.text! "format!"
-    end
-
-    xml.blockquote(:class => 'information') do |bq|
-      bq.text! "Citations are easy too."
-      bq.text! "Really. And you can assign them attributes."
-    end
-
-    xml.ul do |ul|
-      ul.li "Lists"
-      ul.li "aren't"
-      ul.li "difficult"
-      ul.li "either."
-    end
-
-
-Following is a complete example which shows how to use this extension in a page file which generates
-a custom XML document (the `content` block has to be valid Ruby!):
-
-    ---
-    output_path_style: [:parent, :basename, ['.', :lang], '.xml']
-    title: Person Object
-    template: ~
-    --- pipeline:builder
-    xml.persons(:path => context.node.alcn) do |p|
-      p.person do |b|
-        b.firstname('Thomas')
-        b.lastname('Leitner')
-      end
-      p.person do |b|
-        b.firstname('Other first')
-        b.lastname('Other last')
-      end
-    end
-
-The above will produce the following output:
-
-    <persons path="/test.xml">
-      <person>
-        <firstname>Thomas</firstname>
-        <lastname>Leitner</lastname>
-      </person>
-      <person>
-        <firstname>Other first</firstname>
-        <lastname>Other last</lastname>
-      </person>
-    </persons>
-
-
-[1]: http://builder.rubyforge.org "Homepage of builder library"

data/doc/contentprocessor/erb.page

@@ -1,60 +0,0 @@
----
-title: Webgen::ContentProcessor::Erb
----
-## Description
-
-This processer uses ERB (embedded Ruby) to process content. For detailed information about ERB have
-a look at its documentation by executing `ri ERB` or the [ruby documentation
-site](http://www.ruby-doc.org/)!
-
-You can use the special object `context` in your ERB code which provides the whole rendering context
-and, for example, the following useful methods:
-
-* `website`: Provides access to the `Webgen::Website` object which can be used to access all aspects
-  of the currently rendered website.
-
-* `node` (or `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`: The node in which the result gets inserted. Should be used for calculating relative
-  paths.
-
-For a complete list of supported methods have a look at the API documentation for
-[Webgen::Context](../rdoc/Webgen/Context.html).
-
-Here is a small usage example. The following put in a page file
-
-    Counting 5 items dynamically:
-    <%% for i in 1..5 %>
-      * item <%%= i %>
-    <%% end %>
-
-    Outputting all meta information:
-    <%% context.node.meta_info.each do |k,v| %>
-      * <%%= k %> = <%%= v %>
-    <%% end %>
-
-... will give the result:
-
-    Counting 5 items dynamically:
-    <% for i in 1..5 %>
-      * item <%= i %>
-    <% end %>
-
-    Outputting all meta information:
-    <% context.node.meta_info.each do |k,v| %>
-      * <%= k %> = <%= v %>
-    <% end %>
-
-The second line shows the first form of the ERB tags which executes Ruby code but does not output
-anything: it just starts a `for` loop. On the third line the second form of ERB tags is used to
-output the result of the Ruby code (note the equation sign!). And the fourth line completes the
-`for` loop by adding the needed `end` keyword.
-
-> You may need to ensure that the ERB start and end tags are not processed by the content
-> processor. For example, when using the RedCloth content processor, you may need to surround the
-> ERB code with `<notextile>` tags!
-{:.important}

data/doc/contentprocessor/erubis.page

@@ -1,46 +0,0 @@
----
-title: Webgen::ContentProcessor::Erubis
----
-## Description
-
-This processor uses the [Erubis][1] library to process embedded Ruby statements. Erubis is quite a
-bit faster than the standard ERB library that is shipped with Ruby and provides many other useful
-options.
-
-> This extension is only available if you have installed the [erubis][1] library. The preferred
-> way to do this is via Rubygems:
->
->     gem install erubis
-{:.warning}
-
-[1]: http://www.kuwata-lab.com/erubis/ "Erubis Homepage"
-
-You can use some special objects provided by webgen in your embedded Ruby code. These are the same
-objects that are available to the `erb` processor, have a look at its [documentation
-page](erb.html).
-
-The default mode of Erubis works like ERB. So everyting said on the [erb page](erb.html) is also
-true for Erubis. However, you can customize how this processor works by using the following
-configuration options:
-
-* `contentprocessor.erubis.use_pi`: Use processing instructions instead of ERB like
-  instructions. Normally you use statements like `<%% result = some_method_call(opts) %>` or `<%%=
-  context.content_node.alcn %>` in your content. When setting this option to `true`, you can
-  use XML processing instructions instead, like this: `<?rb result = some_method_call(opts) ?>` or
-  `@{context.content_node.alcn}@`.
-
-* `contentprocessor.erubis.options`: This is hash which is passed to the Erubis interpreter and
-  which can be used to set additional options.
-
-For more information on the additional options or on how to use the processing instructions mode of
-Erubis, have a look at the [Erubis User Guide](http://www.kuwata-lab.com/erubis/users-guide.html)!
-
-You can also use block options to modify the behavior of Erubis. The block option `erubis_use_pi` is
-used instead of the configuration option `contentprocessor.erubis.use_pi` and all other block
-options starting with `erubis_` are added the options hash that is passed to the Erubis
-interpreter. For example, the following page tells the Erubis interpreter to use the processing
-instructions mode and to trim spaces:
-
-    --- erubis_use_pi:true erubis_trim:true
-    Here are the numbers from 1 to 5:
-    <?rb for i in [1,2,3,4,5] ?>@{i}@<?rb end ?>

data/doc/contentprocessor/fragments.page

@@ -1,26 +0,0 @@
----
-title: Webgen::ContentProcessor::Fragments
----
-## Description
-
-This processor generates nested fragment nodes from all headers `h1` to `h6` which have an `id`
-attribute set.
-
-> This is only done for the block named `content` or if no block is associated with the given render
-> context! This is to ensure that fragment nodes are not created from multiple block of one page
-> file. So this content processor has no effect when used in the pipeline of blocks except if the
-> block is named `content`.
-{:.warning}
-
-The default markup language kramdown automatically generates an `id` attribute for all headers. If
-you use another markup language or plain old HTML, you might need to set the `id` attributes by
-hand.
-
-> The reason why only header tags with an `id` attribute are used is that only those can be
-> referenced and linked to later.
-{:.information}
-
-The generated fragment nodes can be used like any other node. So you can link to them and use them
-in a menu. Concerning the menu, there is a setting for the `tag.menu.used_nodes` option called
-`fragments` which only uses the fragment node of the current page to generate a menu. This allows to
-generate a nice overview of the page.

data/doc/contentprocessor/haml.page

@@ -1,46 +0,0 @@
----
-title: Webgen::ContentProcessor::Haml
----
-## Description
-
-This processor converts the content, which is assumed to be in the Haml markup language, to valid
-XHTML by using the Haml library. For detailed information about Haml have a look at the [Haml
-Homepage][1]!
-
-You can use some special objects provided by webgen in your Haml markup. These are the same objects
-that are available to the `erb` processor, have a look at its [documentation page](erb.html).
-
-> This extension is only available if you have installed the [haml][1] library. The preferred way to
-> do this is via Rubygems:
->
->     gem install haml
-{:.warning}
-
-
-## Example
-
-Here is a short sample of a text in Haml markup:
-
-    %h1#myid This a h1 header
-
-    %p
-      You can just write
-      %b your
-      paragraphs here and
-      %a{:href => 'http://someurl.com'} link
-      them below. This is a
-      %strong nice
-      format!
-
-    %blockquote.information
-      Citations are easy too.
-      Really. And you can assign them attributes.
-
-    %ul
-      %li Lists
-      %li aren't
-      %li difficult
-      %li either.
-
-
-[1]: http://haml.hamptoncatlin.com/

data/doc/contentprocessor/head.page

@@ -1,31 +0,0 @@
----
-title: Webgen::ContentProcessor::Head
----
-## Description
-
-This processor is used to insert various HTML tags (`link`, `script` and `meta`) before the end of
-the HTML head section. The tags that tags are inserted can be specified in various ways:
-
-* Links to used javascript and css files, inline javascript and css content and general meta tags
-  can be set by webgen tags (or by any other webgen extension) on a page-per-page basis.
-
-* Arbitrary meta tags can be inserted on a page-per-page basis by the user by setting the meta
-  information named [`meta`](../reference_metainfo.html#meta) on a page file.
-
-* Links to javascript and/or CSS files can be inserted by the user by setting the meta information
-  named [`link`](../reference_metainfo.html#link).
-
-* Arbitrary link tags can also be inserted by setting the meta information named
-  [`link`](../reference_metainfo.html#link). This allows one, for example, to specify which page
-  file logically follows or precedes a given page file.
-
-The processor also automatically inserts `link` tags to translations of the rendered page file.
-
-This content processor should be used on template files since its output is only useful in the head
-section of an HTML file. And it should be the last content processor in the pipeline because
-otherwise not all needed information is available! There is no need for a special markup since the
-HTML head end tag is unique in a HTML element and therefore the insertion place can easily be found.
-
-Developers wanting to use the functionality of this content processor should have a look at its [API
-documentation](../rdoc/Webgen/ContentProcessor/Head.html).
-

data/doc/contentprocessor/kramdown.page

@@ -1,49 +0,0 @@
----
-title: Webgen::ContentProcessor::Kramdown
----
-## Description
-
-This processor converts the content, which is assumed to be in kramdown format, to HTML by using the
-[kramdown][1] library. The kramdown format is basically Markdown with some extensions like automatic
-header ID generation, using markup inside HTML elements and some more. There are a [quick
-reference][2] and a detailed [syntax documentation][3] available on the kramdown homepage.
-
-One can customize how this processor works by using the following configuration options:
-
-* `contentprocessor.kramdown.handle_links`: If `true` (the default), then all link URLs created via
-  kramdown syntax are automatically run through the [relocatable tag](../tag/relocatable.html). This
-  avoids using the `relocatable` tag explicitly but ensures valid links nonetheless.
-
-* `contentprocesoor.kramdown.options`: This configuration option can be used to customize the
-  kramdown processor. Have a look at the [kramdown homepage][1] for available options.
-
-> kramdown is the default markup content processor for webgen as its markup syntax is easy to learn
-> and nice to look at. Give it a try!
-{:.info}
-
-Example
--------
-
-Here is a short sample of a text in kramdown markup:
-
-    # This a h1 header
-    {:#myid}
-
-    You can just write *your* paragraphs here and
-    [link][1] them below. This is **nice** format!
-
-    > Citations are easy too.
-    > Really. And you can assign them attributes.
-    {:.information}
-
-    * Lists
-    * aren't
-    * difficult
-    * either.
-
-    [1]: http://someurl.com
-
-
-[1]: http://kramdown.rubyforge.org/
-[2]: http://kramdown.rubyforge.org/syntax.html
-[3]: http://kramdown.rubyforge.org/quickref.html

data/doc/contentprocessor/less.page

@@ -1,34 +0,0 @@
----
-title: Webgen::ContentProcessor::Less
----
-## Description
-
-This content processor converts content in LESS format to valid CSS using the [LESS library][1].
-
-LESS is an extension of CSS which allows the use of variables, mixins, operations and nested rules.
-Since a normal CSS file is a valid LESS file, the transition to LESS is very easy. For detailed
-information about LESS have a look at its [documentation page][2]!
-
-> This extension is only available if you have installed the [less][1] library. The preferred way to
-> do this is via Rubygems:
->
->     gem install less
-{:.warning}
-
-
-## Example
-
-Here is a short sample of a text in LESS format:
-
-    @base: #543;
-
-    #header {
-      color: @base;
-      a {
-        color: @base * 2;
-        text-decoration: underline;
-      }
-    }
-
-[1]: http://lesscss.org/
-[2]: http://lesscss.org/docs.html

data/doc/contentprocessor/maruku.page

@@ -1,44 +0,0 @@
----
-title: Webgen::ContentProcessor::Maruku
----
-## Description
-
-This processor converts the content, which is assumed to be in Markdown markup, to HTML by using the
-Maruku library. Maruku is a Markdown processor which supports a superset of Markdown, including
-support for assigning ids and classes to every element, support for Markdown inside HTML elements
-and footnotes.
-
-For detailed information about Maruku have a look at the [Maruku Homepage][1]. There you will find
-information about the general Markdown syntax as well as information about the extras added by
-Maruku.
-
-> This extension is only available if you have installed the [maruku][1] library. The preferred
-> way to do this is via Rubygems:
->
->     gem install maruku
-{:.warning}
-
-
-Example
--------
-
-Here is a short sample of a text in Markdown+Extras markup:
-
-    # This a h1 header    {#myid}
-
-    You can just write *your* paragraphs here and
-    [link][1] them below. This is **nice** format!
-
-    > Citations are easy too.
-    > Really. And you can assign them attributes.
-    {.information}
-
-    * Lists
-    * aren't
-    * difficult
-    * either.
-
-    [1]: http://someurl.com
-
-
-[1]: http://maruku.rubyforge.org/

data/doc/contentprocessor/rdiscount.page

@@ -1,37 +0,0 @@
----
-title: Webgen::ContentProcessor::RDiscount
----
-## Description
-
-This processor converts the content, which is assumed to be in Markdown markup, to HTML by using the
-RDiscount library. This library is based on the C based discount library which provides very fast
-Markdown processing. However, this processor does not support advanced features like the [kramdown
-processor](kramdown.html) or [Maruku Markdown processor](maruku.html) do.
-
-> This extension is only available if you have installed the [rdiscount][1] library. The preferred
-> way to do this is via Rubygems:
->
->     gem install rdiscount
-{:.warning}
-
-[1]: http://github.com/rtomayko/rdiscount
-
-Example
--------
-
-Here is a short sample of a text in Markdown markup:
-
-    # This a h1 header
-
-    You can just write *your* paragraphs here and
-    [link][1] them below. This is **nice** format!
-
-    > Citations are easy too.
-    > Really. And you can assign them attributes.
-
-    * Lists
-    * aren't
-    * difficult
-    * either.
-
-    [1]: http://someurl.com