gettalong-webgen 0.5.9.20090620 → 0.5.9.20090626

data/data/webgen/passive_sources/templates/sitemap.template

@@ -0,0 +1,21 @@
+---
+template: ~
+--- pipeline:erb
+<?xml version="1.0" encoding="utf-8" ?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+<%
+context.node.alcns.each do |alcn|
+  item = context.node.tree[alcn]
+%>
+  <url>
+    <loc><%= URI.escape(File.join(context.node['site_url'], item.path)) %></loc>
+    <lastmod><%= item['modified_at'].iso8601 %></lastmod>
+    <changefreq><%= item['change_freq'] || context.node['default_change_freq'] %></changefreq>
+    <% if priority = item['priority'] || context.node['default_priority'] %>
+    <priority><%= priority %></priority>
+    <% end %>
+  </url>
+<%
+end
+%>
+</urlset>

data/doc/contentprocessor/head.page

@@ -0,0 +1,21 @@
+---
+title: Webgen::ContentProcessor::Head
+---
+## Description
+
+This processor inserts before the end of the HTML head section links to used javascript and css
+files, inline javascript and css content and general meta tags. This functionality can be used, for
+example, by webgen tags to add needed javascript or css fragments on a page-per-page basis.
+
+It can also be used to insert arbitrary meta tags on a page-per-page basis. This can be done by
+setting the meta information named [`meta`]({relocatable: ../reference_metainfo.html#meta}) on a
+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/manual.page

@@ -567,14 +567,21 @@ There are several types of extensions:
     Webgen Page Format. It is not specified how they have to process the content but this type of
     extension can basically be divided into two groups:
 
-    * Markup processors: Processors like Maruku or RedCloth belong to this group and they convert
-      markup text that is easy to read and write to a more structure format like HTML. This allows
-      you to write an HTML page without knowing HTML.
-
-    * String replacers: These processors normally process special strings and substitute them with
-      other content. For example, the `erb` processors replaces delimited strings interpreted as
-      Ruby code with the interpreted value. Another example would be webgen's `tags` processor which
-      replaces strings like `\{relocatable: ../index.html}` with a processed value.
+    * Text content processors: These processors are used to process textual content like files in
+      Webgen Page Format. This group can furthe be divided:
+
+        * Markup processors: Processors like Maruku or RedCloth belong to this group and they
+          convert markup text that is easy to read and write to a more structure format like HTML.
+          This allows you to write an HTML page without knowing HTML.
+
+        * String replacers: These processors normally process special strings and substitute them
+          with other content. For example, the `erb` processors replaces delimited strings
+          interpreted as Ruby code with the interpreted value. Another example would be webgen's
+          `tags` processor which replaces strings like `\{relocatable: ../index.html}` with a
+          processed value.
+
+    * Binary content processors: These processors are used to process binary data. For example, one
+      might want to process an image to produce a thumbnailed version of it.
 
 *   **Source Handler**: These extensions are used for handling source paths. They read the content of
     a path and produce one or more nodes (the internal representation of an output path, see [source

data/doc/reference_configuration.page

@@ -354,12 +354,14 @@ configuration options) and/or how to use it in a webgen tag (for tag configurati
 *   ### contentprocessor.map
 
     This configuration option maps short names for content processor to their class names. The short
-    names are used, for example, in the procesing pipeline of a content block of a file in Webgen
+    names are used, for example, in the processing pipeline of a content block of a file in Webgen
     Page Format. This configuration option is normally only used by extensions to register the short
     name of a content processor!
 
-    * Syntax: `\{SHORT: NAME, ...}` where `SHORT` is the short name of the content processor class
-      `NAME`.
+    * Syntax: `\{SHORT: NAME, SHORT: [NAME, TYPE], ...}` where `SHORT` is the short name of the
+      content processor class `NAME`. The second form allows one to additionally specify the type
+      `TYPE` of the content processor which has to be `:binary` or `:text`. If the first form is
+      used, then the type defaults to `:text`.
 
     <%= show_default['contentprocessor.map'] %>
 
@@ -367,6 +369,7 @@ configuration options) and/or how to use it in a webgen tag (for tag configurati
 
           config = Webgen::WebsiteAccess.website.config
           config['contentprocessor.map']['newcp'] = 'Extension::MyNewContentProcessor'
+          config['contentprocessor.map']['newcp'] = ['Extension::MyNewContentProcessor', :binary]
 
 
 *   ### contentprocessor.erubis.use\_pi

data/doc/reference_metainfo.page

@@ -110,7 +110,7 @@ information for nodes created by them.
 
 {:miref}
 * String: `de`
-* Page files
+* Any
 
 Sets the language for the path. Has to be a valid ISO-639-1/2 character code for the language. This
 meta information needs to be set before a node gets created.
@@ -124,6 +124,16 @@ meta information needs to be set before a node gets created.
 Specifies additional attribute-value pairs (in form of a Hash) that should be added to a link to the
 path.
 
+### meta
+
+{:miref}
+* Hash: `\{author: Thomas Leitner, generator: My program}`
+* Any
+
+Specifies names and values for `<meta>` HTML tags. These key-value pairs are then properly escaped
+and inserted into the output file by [`ContentProcessor::Head`]({relocatable:
+contentprocessor/head.html}).
+
 ### modified\_at
 
 {:miref}

data/doc/reference_website_styles.page

@@ -20,7 +20,7 @@ context.content_node.tree.node_access[:alcn].select do |name, node|
   node.is_directory? && node.parent == context.content_node.tree[File.join(context.content_node.parent.alcn, '/website_styles/')]
 end.sort.each do |name, node|
 %>
-<h2 id="<%= node.cn %>"><%= node.cn %></h2>
+<h2 id="<%= node.cn.chomp('/') %>"><%= node.cn %></h2>
 <div class="website-styles">
 <%= context.dest_node.link_to(node, :link_text => "Full window version") %>
 <object type="text/html" data="<%= context.dest_node.route_to(node) %>">Nothing</object>

data/doc/sourcehandler/sitemap.page

@@ -7,12 +7,6 @@ This source handler automatically generates a sitemap based on the specification
 [sitemaps.org](http://sitemaps.org) from a file in [Webgen Page Format]({relocatable:
 ../webgen_page_format.html}).
 
-> This extension can only be used if you have installed the [builder](http://builder.rubyforge.org)
-> library. The preferred way to do this is via Rubygems:
->
->     gem install builder
-{.warning}
-
 The following meta information keys are supported:
 
 *   `site_url` (MANDATORY)
@@ -44,3 +38,9 @@ The following meta information keys of files are used if they are specified:
 *   `priority`
 
     The priority of the file in respect to the other files.
+
+The generation of the sitemap is done via a template and the template used needs to be located under
+the ALCN `/templates/sitemap.template`. This default template is automatically created and used if
+no such path exists in the webgen website. You can also override the default generation mechanism on
+a file per file basis by adding a `template` block in the sitemap file which is then used to generate
+the sitemap.

data/lib/webgen/contentprocessor.rb

@@ -18,8 +18,13 @@ module Webgen
   #
   # After writing the content processor class, one needs to add it to the
   # <tt>contentprocessor.map</tt> hash so that it is used by webgen. The key for the entry needs to
-  # be a short name without special characters or spaces and the value is the class name, not as
-  # constant but as a string.
+  # be a short name without special characters or spaces and the value can be:
+  #
+  # * the class name, not as constant but as a string - then this content processor is assumed to
+  #   work with textual data -, or
+  #
+  # * an array with the class name like before and the type, which needs to be <tt>:binary</tt> or
+  #   <tt>:text</tt>.
   #
   # == Sample Content Processor
   #
@@ -52,6 +57,8 @@ module Webgen
   #   end
   #
   #   WebsiteAccess.website.config['contentprocessor.map']['replacer'] = 'SampleProcessor'
+  #   # Or one could equally write
+  #   # WebsiteAccess.website.config['contentprocessor.map']['replacer'] = ['SampleProcessor', :text]
   #
   module ContentProcessor
 
@@ -67,6 +74,7 @@ module Webgen
     autoload :Erubis, 'webgen/contentprocessor/erubis'
     autoload :RDiscount, 'webgen/contentprocessor/rdiscount'
     autoload :Fragments, 'webgen/contentprocessor/fragments'
+    autoload :Head, 'webgen/contentprocessor/head'
 
     # Return the list of all available content processors.
     def self.list
@@ -75,10 +83,16 @@ module Webgen
 
     # Return the content processor object identified by +name+.
     def self.for_name(name)
-      klass = WebsiteAccess.website.config['contentprocessor.map'][name]
+      klass, cp_type = WebsiteAccess.website.config['contentprocessor.map'][name]
       klass.nil? ? nil : WebsiteAccess.website.cache.instance(klass)
     end
 
+    # Return whether the content processor identified by +name+ is processing binary data.
+    def self.is_binary?(name)
+      WebsiteAccess.website.config['contentprocessor.map'][name].kind_of?(Array) &&
+        WebsiteAccess.website.config['contentprocessor.map'][name].last == :binary
+    end
+
     # Helper class for accessing content processors in a Webgen::Context object.
     class AccessHash
 

data/lib/webgen/contentprocessor/head.rb

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+module Webgen::ContentProcessor
+
+  # Inserts additional links to CSS/JS files and other HTML head meta info directly before the HTML
+  # head end tag.
+  #
+  # The data used by this content processor is taken from the Context object. Therefore this
+  # processor should be the last in the processing pipeline so that all other processors have been
+  # able to set the data.
+  #
+  # The key <tt>:cp_head</tt> of <tt>context.options</tt> is used and it has to be a Hash with the
+  # following values:
+  #
+  # [:js_file] An array of already resolved relative or absolute paths to Javascript files.
+  # [:js_inline] An array of Javascript fragments to be inserted directly into the head section.
+  # [:css_file] An array of already resolved relative or absolute paths to CSS files.
+  # [:css_inline] An array of CSS fragments to be inserted directly into the head section.
+  # [:meta] A hash with key-value pairs from which <tt>meta</tt> tags are generated. The keys and
+  #         the values will be properly escaped before insertion. The entries in the meta
+  #         information <tt>meta</tt> of the content node are also used and take precedence over
+  #         these entries.
+  class Head
+
+    include Webgen::Loggable
+
+    HTML_HEAD_END_RE = /<\/head\s*>/i #:nodoc:
+
+    # Insert the additional header information.
+    def call(context)
+      require 'erb'
+      context.content.sub!(HTML_HEAD_END_RE) do |match|
+        result = ''
+        if context[:cp_head].kind_of?(Hash)
+          context[:cp_head][:js_file].each do |js_file|
+            result += "\n<script type=\"text/javascript\" src=\"#{js_file}\"></script>"
+          end if context[:cp_head][:js_file].kind_of?(Array)
+
+          context[:cp_head][:js_inline].each do |content|
+            result += "\n<script type=\"text/javascript\">\n#{content}\n</script>"
+          end if context[:cp_head][:js_inline].kind_of?(Array)
+
+          context[:cp_head][:css_file].each do |css_file|
+            result += "\n<link rel=\"stylesheet\" href=\"#{css_file}\" type=\"text/css\"/>"
+          end if context[:cp_head][:css_file].kind_of?(Array)
+
+          context[:cp_head][:css_inline].each do |content|
+            result += "\n<style type=\"text/css\"><![CDATA[/\n#{content}\n]]></style>"
+          end if context[:cp_head][:css_inline].kind_of?(Array)
+
+          context[:cp_head][:meta].merge(context.node['meta'] || {}).each do |name, content|
+            result += "\n<meta name=\"#{ERB::Util.h(name)}\" content=\"#{ERB::Util.h(content)}\" />"
+          end if context[:cp_head][:meta].kind_of?(Hash)
+        end
+        result + match
+      end
+      context
+    end
+
+  end
+
+end

data/lib/webgen/default_config.rb

@@ -89,19 +89,21 @@ config.sourcehandler.default_meta_info({
                                            'kind' => 'fragment'
                                          },
                                          'Webgen::SourceHandler::Template' => {
-                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,blocks'}}
+                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,blocks,head'}}
                                          },
                                          'Webgen::SourceHandler::Metainfo' => {
                                            'blocks' => {1 => {'name' => 'paths'}, 2 => {'name' => 'alcn'}}
                                          },
                                          'Webgen::SourceHandler::Feed' => {
                                            'rss' => true,
-                                           'atom' => true
+                                           'atom' => true,
+                                           'blocks' => {'default' => {'pipeline' => 'erb'}}
                                          },
                                          'Webgen::SourceHandler::Sitemap' => {
                                            'default_priority' => 0.5,
                                            'default_change_freq' => 'weekly',
-                                           'common.sitemap.any_lang' => true
+                                           'common.sitemap.any_lang' => true,
+                                           'blocks' => {'default' => {'pipeline' => 'erb'}}
                                          }
                                        }, :doc => "Default meta information for all nodes and for nodes belonging to a specific source handler")
 
@@ -137,10 +139,12 @@ config.contentprocessor.map({
                               'erubis' => 'Webgen::ContentProcessor::Erubis',
                               'rdiscount' => 'Webgen::ContentProcessor::RDiscount',
                               'fragments' => 'Webgen::ContentProcessor::Fragments',
+                              'head' => 'Webgen::ContentProcessor::Head'
                             }, :doc => 'Content processor name to class map')
 
 Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_names, Webgen::ContentProcessor.method(:list))
 Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor, Webgen::ContentProcessor.method(:for_name))
+Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_binary?, Webgen::ContentProcessor.method(:is_binary?))
 
 # All things regarding tags
 config.contentprocessor.tags.prefix('', :doc => 'The prefix used for tag names to avoid name clashes when another content processor uses similar markup.')

data/lib/webgen/node.rb

@@ -116,7 +116,7 @@ module Webgen
     end
 
     # Check if the node is a directory.
-    def is_directory?; @path[-1] == ?/; end
+    def is_directory?; @path[-1] == ?/ && !is_fragment?; end
 
     # Check if the node is a file.
     def is_file?; !is_directory? && !is_fragment?; end

data/lib/webgen/output.rb

@@ -18,8 +18,10 @@ module Webgen
   #   Write the +data+ to the given output +path+. The parameter +data+ is either a String with the
   #   content or a Webgen::Path::SourceIO object. The parameter +type+ specifies the type of the to
   #   be written path: <tt>:file</tt> or <tt>:directory</tt>.
-  # [<tt>read(path)</tt>]
-  #   Return the content of the given path if it exists or raise an error otherwise.
+  # [<tt>read(path, mode = 'rb')</tt>]
+  #   Return the content of the given path if it exists or raise an error otherwise. The parameter
+  #   +mode+ specifies the mode in which the path should be opened and defaults to reading in binary
+  #   mode.
   #
   #   It seems a bit odd that an output instance has to implement reading functionality. However,
   #   consider the case where you want webgen to render a website programmatically and *use* the
@@ -52,7 +54,7 @@ module Webgen
   #       @data[path] = [(io.kind_of?(String) ? io : io.data), type]
   #     end
   #
-  #     def read(path)
+  #     def read(path, mode = 'rb')
   #       path = File.join('/', path)
   #       raise "No such file #{path}" unless @data[path] && @data[path].last == :file
   #       @data[path].first

data/lib/webgen/output/filesystem.rb

@@ -50,7 +50,7 @@ module Webgen::Output
         if data.kind_of?(String)
           File.open(dest, 'wb') {|f| f.write(data) }
         else
-          data.stream do |source|
+          data.stream('rb') do |source|
             File.open(dest, 'wb') {|f| FileUtils.copy_stream(source, f) }
           end
         end
@@ -59,9 +59,9 @@ module Webgen::Output
       end
     end
 
-    # Return the content of the given +path+.
-    def read(path)
-      File.open(File.join(@root, path), 'rb') {|f| f.read}
+    # Return the content of the given +path+ which is opened in +mode+.
+    def read(path, mode = 'rb')
+      File.open(File.join(@root, path), mode) {|f| f.read}
     end
 
   end

data/lib/webgen/path.rb

@@ -49,16 +49,21 @@ module Webgen
 
       # Provide direct access to the wrapped IO object by yielding it. After the method block
       # returns the IO object is automatically closed.
-      def stream
-        io = @block.call
+      #
+      # The parameter +mode+ specifies the mode in which the wrapped IO object should be opened.
+      # This can be used, for example, to open a file in binary mode (or specify a certain input
+      # encoding under Ruby 1.9).
+      def stream(mode = 'r')
+        io = @block.call(mode)
         yield(io)
       ensure
         io.close
       end
 
-      # Return the whole content of the wrapped IO object as string.
-      def data
-        stream {|io| io.read}
+      # Return the whole content of the wrapped IO object as string. For a description of the
+      # parameter +mode+ see #stream.
+      def data(mode = 'r')
+        stream(mode) {|io| io.read}
       end
 
     end

data/lib/webgen/source/filesystem.rb

@@ -14,7 +14,7 @@ module Webgen
 
       # Create a new object with absolute path +path+ for the file system path +fs_path+.
       def initialize(path, fs_path)
-        super(path) { File.open(fs_path, 'rb') }
+        super(path) {|mode| File.open(fs_path, mode) }
         @fs_path = fs_path
         WebsiteAccess.website.cache[[:fs_path, @fs_path]] = File.mtime(@fs_path)
         @meta_info['modified_at'] = File.mtime(@fs_path)

data/lib/webgen/source/tararchive.rb

@@ -24,7 +24,7 @@ module Webgen
 
       # Create a new tar archive path object for the entry +entry+.
       def initialize(path, data, mtime, uri)
-        super(path) { StringIO.new(data.to_s) }
+        super(path) {|mode| StringIO.new(data.to_s, mode) }
         @uri = uri
         @mtime = mtime
         WebsiteAccess.website.cache[[:tararchive_path, @uri, path]] = @mtime if WebsiteAccess.website

data/lib/webgen/sourcehandler/copy.rb

@@ -30,7 +30,8 @@ module Webgen::SourceHandler
     def content(node)
       io = website.blackboard.invoke(:source_paths)[node.node_info[:src]].io
       if node.node_info[:preprocessor]
-        context = Webgen::Context.new(:content => io.data, :chain => [node])
+        is_binary = website.blackboard.invoke(:content_processor_binary?, node.node_info[:preprocessor])
+        context = Webgen::Context.new(:content => io.data(is_binary ? 'rb' : 'r'), :chain => [node])
         website.blackboard.invoke(:content_processor, node.node_info[:preprocessor]).call(context)
         context.content
       else

data/lib/webgen/sourcehandler/sitemap.rb

@@ -16,32 +16,28 @@ module Webgen::SourceHandler
 
     # Create an XML sitemap from +path+.
     def create_node(path)
-      page_from_path(path)
+      page = page_from_path(path)
       path.ext = 'xml'
       raise "Needed information site_url missing for sitemap <#{path}>" if path.meta_info['site_url'].nil?
-      super(path)
+      super(path) do |node|
+        node.node_info[:sitemap] = page
+      end
     end
 
     # Return the rendered feed represented by +node+.
     def content(node)
-      require 'builder'
-      list = website.blackboard.invoke(:create_sitemap, node, node.lang, options_for_node(node)).to_lcn_list.flatten
-      sitemap = ::Builder::XmlMarkup.new(:indent => 2)
-      sitemap.instruct!(:xml, :version => '1.0', :encoding => 'UTF-8')
-      sitemap.urlset(:xmlns => "http://www.sitemaps.org/schemas/sitemap/0.9") do
-        list.each do |alcn|
-          item = node.tree[alcn]
-          sitemap.url do |url|
-            sitemap.loc(URI.escape(File.join(node['site_url'], item.path)))
-            sitemap.lastmod(item['modified_at'].iso8601)
-            changefreq = item['change_freq'] || node['default_change_freq']
-            sitemap.changefreq(changefreq) if changefreq
-            priority = item['priority'] || node['default_priority']
-            sitemap.priority(priority) if priority
-          end
-        end
+      if node.node_info[:sitemap].blocks.has_key?('template')
+        node.node_info[:sitemap].blocks['template'].render(Webgen::Context.new(:chain => [node])).content
+      else
+        chain = [node.resolve("/templates/sitemap.template"), node]
+        node.node_info[:used_nodes] << chain.first.alcn
+        chain.first.node_info[:page].blocks['content'].render(Webgen::Context.new(:chain => chain)).content
       end
-      sitemap.target!
+    end
+
+    # Return the alcns of the sitemap +node+ as a flat list.
+    def alcns(node)
+      website.blackboard.invoke(:create_sitemap, node, node.lang, options_for_node(node)).to_lcn_list.flatten
     end
 
     #######

data/test/test_contentprocessor.rb

@@ -10,7 +10,7 @@ class TestContentProcessor < Test::Unit::TestCase
 
   def setup
     super
-    @website.config.data['contentprocessor.map'] = {'test' => Hash}
+    @website.config.data['contentprocessor.map'] = {'test' => Hash, 'binary' => [Hash, :binary]}
   end
 
   def test_access_hash
@@ -22,12 +22,18 @@ class TestContentProcessor < Test::Unit::TestCase
   end
 
   def test_list
-    assert_equal(['test'], Webgen::ContentProcessor.list)
+    assert_equal(['binary', 'test'], Webgen::ContentProcessor.list.sort)
   end
 
   def test_for_name
     assert_kind_of(Hash, Webgen::ContentProcessor.for_name('test'))
+    assert_kind_of(Hash, Webgen::ContentProcessor.for_name('binary'))
     assert_nil(Webgen::ContentProcessor.for_name('other'))
   end
 
+  def test_is_binary
+    assert(!Webgen::ContentProcessor.is_binary?('test'))
+    assert(Webgen::ContentProcessor.is_binary?('binary'))
+  end
+
 end

data/test/test_contentprocessor_head.rb

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/page'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorHead < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_call
+    obj = Webgen::ContentProcessor::Head.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+
+    context = Webgen::Context.new(:chain => [node])
+    context.content = '</head>'
+    obj.call(context)
+    assert_equal('</head>', context.content)
+
+    context.content = '</head>'
+    context[:cp_head] = {
+      :js_file => ['hallo.js', 'hallo2.js'],
+      :js_inline => ["somescript", "anotherscript"],
+      :css_file => ['hallo.css', 'hallo2.css'],
+      :css_inline => ["somestyle", "anotherstyle"],
+      :meta => {:lucky => 'me<"'}
+    }
+    obj.call(context)
+    assert_equal("\n<script type=\"text/javascript\" src=\"hallo.js\"></script>" +
+                 "\n<script type=\"text/javascript\" src=\"hallo2.js\"></script>" +
+                 "\n<script type=\"text/javascript\">\nsomescript\n</script>" +
+                 "\n<script type=\"text/javascript\">\nanotherscript\n</script>" +
+                 "\n<link rel=\"stylesheet\" href=\"hallo.css\" type=\"text/css\"/>" +
+                 "\n<link rel=\"stylesheet\" href=\"hallo2.css\" type=\"text/css\"/>" +
+                 "\n<style type=\"text/css\"><![CDATA[/\nsomestyle\n]]></style>" +
+                 "\n<style type=\"text/css\"><![CDATA[/\nanotherstyle\n]]></style>" +
+                 "\n<meta name=\"lucky\" content=\"me&lt;&quot;\" /></head>", context.content)
+  end
+
+end

data/test/test_node.rb

@@ -23,7 +23,7 @@ class TestNode < Test::Unit::TestCase
       :other_en => Webgen::Node.new(node, '/other1.html', 'other.page', {'lang' => 'en'}),
       :somename_en_frag => frag_en = Webgen::Node.new(child_en, '/somename.en.html#frag', '#othertest', {'title' => 'frag'}),
       :somename_de_frag => Webgen::Node.new(child_de, '/somename.de.html#frag', '#othertest'),
-      :somename_en_fragnest => Webgen::Node.new(frag_en, '/somename.en.html#fragnest', '#nestedpath'),
+      :somename_en_fragnest => Webgen::Node.new(frag_en, '/somename.en.html#fragnest/', '#nestedpath'),
       :dir => dir = Webgen::Node.new(node, '/dir/', 'dir/'),
       :dir_file => dir_file = Webgen::Node.new(dir, '/dir/file.html', 'file.html'),
       :dir_file_frag => Webgen::Node.new(dir_file, '/dir/file.html#frag', '#frag'),
@@ -74,6 +74,8 @@ class TestNode < Test::Unit::TestCase
     assert(nodes[:somename_en_frag].is_fragment?)
     assert(nodes[:root].is_root?)
     assert(!nodes[:somename_en].is_root?)
+    assert(nodes[:somename_en_fragnest].is_fragment?)
+    assert(!nodes[:somename_en_fragnest].is_directory?)
   end
 
   def test_meta_info_assignment

data/test/test_path.rb

@@ -3,6 +3,7 @@
 require 'test/unit'
 require 'webgen/path'
 require 'stringio'
+require 'tmpdir'
 
 class TestPath < Test::Unit::TestCase
 
@@ -130,6 +131,19 @@ class TestPath < Test::Unit::TestCase
     p = Webgen::Path.new('/test.de.page') { StringIO.new('hallo') }
     assert_equal('hallo', p.io.data)
     assert_equal('hallo', p.io.stream {|f| f.read })
+
+    if RUBY_VERSION >= '1.9'
+      begin
+        dir = File.join(Dir.tmpdir, 'webgen-' + Process.pid.to_s)
+        FileUtils.mkdir_p(dir)
+        File.open(File.join(dir, 'src'), 'wb+') {|f| f.write("\303\274")}
+        sio = Webgen::Path::SourceIO.new {|mode| File.open(File.join(dir, 'src'), mode) }
+        assert_equal(1, sio.data('r:UTF-8').length)
+        assert_equal(2, sio.data('rb').length)
+      ensure
+        FileUtils.rm_rf(dir) if dir
+      end
+    end
   end
 
   def test_equality
@@ -168,6 +182,7 @@ class TestPath < Test::Unit::TestCase
     path = '/dir/'
     assert(Webgen::Path.match(path, '/dir/'))
     assert(Webgen::Path.match(path, '/dir'))
+    assert(Webgen::Path.match(path, '/*/'))
 
     path = '/dir'
     assert(Webgen::Path.match(path, '/dir/'))

data/test/test_sourcehandler_metainfo.rb

@@ -15,6 +15,9 @@ class TestSourceHandlerMetainfo < Test::Unit::TestCase
 /default.*:
   title: new title
   before: valbef
+
+/*/:
+  title: test
 ---
 /default.css:
   after: valaft
@@ -28,6 +31,7 @@ EOF
     @website.blackboard.add_service(:source_paths) do
       {'/default.css' => path_with_meta_info('/default.css') {StringIO.new('# header')},
         '/other.page' => path_with_meta_info('/other.page') {StringIO.new('other page')},
+        '/hallo/' => path_with_meta_info('/hallo/')
       }
     end
 
@@ -37,7 +41,8 @@ EOF
   end
 
   def test_create_node
-    assert_equal({'/default.*' => {'title' => 'new title', 'before' => 'valbef'}}, @node.node_info[:mi_paths])
+    assert_equal({'/default.*' => {'title' => 'new title', 'before' => 'valbef'},
+                 '/*' => {'title' => 'test'}}, @node.node_info[:mi_paths])
     assert_equal({'/default.css' => {'after' => 'valaft'},
                  '/other.page' => {'title' => 'Not Other'}}, @node.node_info[:mi_alcn])
   end
@@ -75,6 +80,10 @@ EOF
     path = path_with_meta_info('/default.css')
     @website.blackboard.dispatch_msg(:before_node_created, path)
     assert('valbef', path.meta_info['before'])
+
+    path = path_with_meta_info('/hallo/')
+    @website.blackboard.dispatch_msg(:before_node_created, path)
+    assert('test', path.meta_info['title'])
   end
 
   def test_after_node_created

data/test/test_sourcehandler_sitemap.rb

@@ -13,10 +13,21 @@ class TestSourceHandlerSitemap < Test::Unit::TestCase
 ---
 site_url: http://example.com
 default_change_freq: daily
+EOF
+
+  SITEMAP_CONTENT_TEMPLATE = <<EOF
+---
+site_url: http://example.com
+default_change_freq: daily
+--- name:template
+Yeah <%= context.node['title'] %>
 EOF
 
   def setup
     super
+    shm = Webgen::SourceHandler::Main.new
+    @website.blackboard.del_listener(:node_meta_info_changed?, shm.method(:meta_info_changed?))
+    @website.config['passive_sources'] << ['/', "Webgen::Source::Resource", "webgen-passive-sources"]
     @nodes = create_sitemap_nodes
     @nodes.each {|k,v| v['modified_at'] = Time.now}
     @nodes[:file11_en]['priority'] = 0.9
@@ -37,6 +48,14 @@ EOF
     end
   end
 
+  def test_create_node_with_own_template
+    @path = path_with_meta_info('/test.sitemap', {}, @obj.class.name) {StringIO.new(SITEMAP_CONTENT_TEMPLATE)}
+    sitemap = @obj.create_node(@path)
+    sitemap['title'] = 'test'
+    assert_not_nil(sitemap)
+    assert_equal('Yeah test', sitemap.content)
+  end
+
   def test_content
     sitemap = @obj.create_node(@path)
     content = sitemap.content

data/test/test_tag_base.rb

@@ -1,7 +1,5 @@
 # -*- encoding: utf-8 -*-
 
-# -*- encoding: utf-8 -*-
-
 require 'test/unit'
 require 'helper'
 require 'stringio'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gettalong-webgen
 version: !ruby/object:Gem::Version 
-  version: 0.5.9.20090620
+  version: 0.5.9.20090626
 platform: ruby
 authors: 
 - Thomas Leitner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-19 15:00:00 -07:00
+date: 2009-06-25 15:00:00 -07:00
 default_executable: webgen
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -201,6 +201,7 @@ files:
 - data/webgen/passive_sources/templates
 - data/webgen/passive_sources/templates/atom_feed.template
 - data/webgen/passive_sources/templates/rss_feed.template
+- data/webgen/passive_sources/templates/sitemap.template
 - data/webgen/resources.yaml
 - data/webgen/webgui
 - data/webgen/webgui/app.rb
@@ -359,6 +360,7 @@ files:
 - doc/contentprocessor/erubis.page
 - doc/contentprocessor/fragments.page
 - doc/contentprocessor/haml.page
+- doc/contentprocessor/head.page
 - doc/contentprocessor/maruku.page
 - doc/contentprocessor/rdiscount.page
 - doc/contentprocessor/rdoc.page
@@ -424,6 +426,7 @@ files:
 - lib/webgen/contentprocessor/erubis.rb
 - lib/webgen/contentprocessor/fragments.rb
 - lib/webgen/contentprocessor/haml.rb
+- lib/webgen/contentprocessor/head.rb
 - lib/webgen/contentprocessor/maruku.rb
 - lib/webgen/contentprocessor/rdiscount.rb
 - lib/webgen/contentprocessor/rdoc.rb
@@ -510,6 +513,7 @@ files:
 - test/test_contentprocessor_erubis.rb
 - test/test_contentprocessor_fragments.rb
 - test/test_contentprocessor_haml.rb
+- test/test_contentprocessor_head.rb
 - test/test_contentprocessor_maruku.rb
 - test/test_contentprocessor_rdiscount.rb
 - test/test_contentprocessor_rdoc.rb