gettalong-webgen 0.5.5.20081001 → 0.5.5.20081010

data/doc/extensions.page

@@ -6,7 +6,7 @@ title: Extensions
 Following is a listing of all available extensions:
 
 <%
-pattern = /#{File.join(node.parent.absolute_lcn, '/')}(contentprocessor|output|source|sourcehandler|tag|)\//
+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|
 next if n.is_fragment?
 %>

data/doc/reference_configuration.page

@@ -659,6 +659,91 @@ files in Webgen Page Format.
           <a href="\{relocatable: ../features.html}">Some Path</a>
 
 
+*   ### tag.tikz.path
+
+    The default mandatory configuration option for Tag::TikZ that specifies the (naturally
+    non-existing) source path that should be used for creating the TikZ image. The output path is
+    derived from this path the usual way. You shouldn't use a path that does already exist!
+
+    * Syntax: `PATH` where `PATH` is a relative or absolute source path.
+
+    * Examples:
+
+          \{tikz:: images/tikz.png}\tikz \draw (0,0) -- (0,2);{tikz}
+
+
+*   ### tag.tikz.libraries
+
+    Specifies the names of additional TikZ library names that should be used when creating the
+    image.
+
+    * Syntax: `[NAME, ...]` where `NAME` is the name of a TikZ library.
+
+    * Examples:
+
+          \{tikz:: {path: images/tikz.png, libraries: [mindmap, arrows]}}
+          \tikz \draw (0,0) -- (0,2) -- (2,2);
+          {tikz}
+
+
+*   ### tag.tikz.opts
+
+    Specifies additional global options for the `tikzpicture` environment.
+
+    * Syntax: `OPTS` where `OPTS` is the string with the global options.
+
+    * Examples:
+
+          \{tikz:: {path: images/tikz.png, opts: 'scale=3, line cap=round'}}
+          \tikz \draw (0,0) -- (0,2) -- (2,2);
+          {tikz}
+
+
+*   ### tag.tikz.resolution
+
+    Specifies the render and output resolutions that should be used to convert the TikZ image in PDF
+    format to the chosen image format. The first number specifies the render resolution and the
+    second one the output resolution. If the render resolution is higher than the output resolution,
+    the final image quality is better but the image needs to scaled down to the output resolution.
+
+    * Syntax: `RENDER_RES OUTPUT_RES` where `RENDER_RES` is the integer specifying the render
+      resolution and `OUTPUT_RES` is the integer specifying the output resolution.
+
+    * Examples:
+
+          \{tikz:: {path: images/tikz.png, resolution: 300 72}}
+          \tikz \draw (0,0) -- (0,2) -- (2,2);
+          {tikz}
+
+
+*   ### tag.tikz.transparent
+
+    Specifies whether the generated image should be transparent. This only works when the path
+    specified by `tag.tikz.path` option has the extension `.png`! You should probably also set the
+    background of the generated image tag to transparent.
+
+    * Syntax: `BOOLEAN` where `BOOLEAN` is either `true` or `false`.
+
+    * Examples:
+
+          \{tikz:: {path: images/tikz.png, transparent: true}}
+          \tikz \draw (0,0) -- (0,2) -- (2,2);
+          {tikz}
+
+
+*   ### tag.tikz.img\_attr
+
+    Specifies additional HTML attributes that should be set on the generated `img` tag.
+
+    * Syntax: `\{KEY:VALUE, ...}` where `KEY` is a valid HTML `img` tag attribute name and `VALUE`
+      the to-be-set value.
+
+    * Examples:
+
+          \{tikz:: {path: images/tikz.png, img_attr: {alt: Some TikZ picture}}}
+          \tikz \draw (0,0) -- (0,2) -- (2,2);
+          {tikz}
+
 ---
 
 ## Miscelleanous Configuration Options

data/doc/tag/tikz.page

@@ -0,0 +1,158 @@
+---
+title: Webgen::Tag::TikZ
+used_options:
+  - tag.tikz.path
+  - tag.tikz.libraries
+  - tag.tikz.opts
+  - tag.tikz.resolution
+  - tag.tikz.transparent
+  - tag.tikz.img_attr
+---
+## Description
+
+This tag provides support for automatically generating graphics with the fantastic PGF/TikZ library
+for LaTeX. You will need to have a current LaTeX distribution with the PGF/TikZ library installed
+and ImageMagick for this to work. You will also need Ghostscript if you want support for transparent
+PNG images. More exactly, you will need to have the programs `pdflatex` (usually included in the
+LaTeX distribution - for generating a PDF from the LaTeX document that describes the PGF/TikZ
+graphic), `pdfcrop` (usually included in the LaTeX distribution - to crop the generated PDF and
+throw away useless borders), `convert` (provided by ImageMagick - to convert the generated PDF
+document to an image file format and to optionally resize them) and `gs` (provided by the
+Ghostscript package - to generate transparent PNG images).
+
+When using this tag, you need to set at least the default mandatory parameter `tag.tikz.path`. This
+path specifies the source path that should be used for generating the image and should not
+exist. The output path is dervied from this path the usual way. The extension used for this
+parameter specifies the final image format that is used (a good choice is PNG). All other parameters
+are optional. The commands for creating the PGF/TikZ picture are specified in the body of the
+tag. Have a look at some of the examples below to set the power of PGF/TikZ.
+
+If you want to generate transparent images, you will need to set `tag.tikz.transparent` to `true`
+and specify a `tag.tikz.path` with a `.png` extension.
+
+## Examples
+
+These examples are taken (sometimes a little bit altered) from the great PGF Manual included in the
+PGF/TikZ distribution.
+
+<table class="examples">
+<tr>
+  <th>Usage</th><th>Output</th>
+</tr>
+
+<tr>
+  <td>
+  <pre>
+  \{tikz:: house.png}
+  \tikz \draw[thick,rounded corners=8pt]
+  (0,0) -- (0,2) -- (1,3.25) -- (2,2) -- (2,0) -- (0,2) -- (2,2) -- (0,0) -- (2,0);
+  {tikz}
+  </pre>
+  </td>
+  <td>
+  {tikz:: house.png}
+  \tikz \draw[thick,rounded corners=8pt]
+  (0,0) -- (0,2) -- (1,3.25) -- (2,2) -- (2,0) -- (0,2) -- (2,2) -- (0,0) -- (2,0);
+  {tikz}
+  </td>
+</tr>
+
+<tr>
+  <td>
+  <pre>
+  \{tikz:: {path: chain.png, libraries: [arrows,automata,shadows,positioning],
+    opts: "->,>=stealth,shorten >=1pt,auto,node distance=2.8cm,on grid,semithick,
+    every state/.style={fill=red,draw=none,circular drop shadow,text=white}",
+    resolution: 300 72}}
+\node[initial,state] (A) {$q_a$};
+\node[state] (B) [above right=of A] {$q_b$};
+\node[state] (D) [below right=of A] {$q_d$};
+\node[state] (C) [below right=of B] {$q_c$};
+\node[state] (E) [below=of D] {$q_e$};
+\path (A) edge node {0,1,L} (B)
+edge node {1,1,R} (C)
+(B) edge [loop above] node {1,1,L} (B)
+edge node {0,1,L} (C)
+(C) edge node {0,1,L} (D)
+edge [bend left] node {1,0,R} (E)
+(D) edge [loop below] node {1,1,R} (D)
+edge node {0,1,R} (A)
+(E) edge [bend left] node {1,0,R} (A);
+  {tikz}
+  </pre>
+  </td>
+  <td>
+  {tikz:: {path: chain.png, libraries: [arrows,automata,shadows,positioning],
+    opts: "->,>=stealth,shorten >=1pt,auto,node distance=2.8cm,on grid,semithick,
+    every state/.style={fill=red,draw=none,circular drop shadow,text=white}"}}
+\node[initial,state] (A) {$q_a$};
+\node[state] (B) [above right=of A] {$q_b$};
+\node[state] (D) [below right=of A] {$q_d$};
+\node[state] (C) [below right=of B] {$q_c$};
+\node[state] (E) [below=of D] {$q_e$};
+\path (A) edge node {0,1,L} (B)
+edge node {1,1,R} (C)
+(B) edge [loop above] node {1,1,L} (B)
+edge node {0,1,L} (C)
+(C) edge node {0,1,L} (D)
+edge [bend left] node {1,0,R} (E)
+(D) edge [loop below] node {1,1,R} (D)
+edge node {0,1,R} (A)
+(E) edge [bend left] node {1,0,R} (A);
+  {tikz}
+  </td>
+</tr>
+
+<tr>
+  <td>
+  Not transparent and standard res
+  <pre>
+  \{tikz:: {path: mindmap.png, libraries: [mindmap]}}
+  \path[mindmap,concept color=black,text=white]
+    node[concept] {Computer Science}
+    [clockwise from=0]
+    child[concept color=red] { node[concept] {technical} }
+    child[concept color=orange] { node[concept] {theoretical} };
+  {tikz}
+  </pre>
+  </td>
+  <td>
+  {tikz:: {path: mindmap.png, libraries: [mindmap]}}
+  \path[mindmap,concept color=black,text=white]
+    node[concept] {Computer Science}
+    [clockwise from=0]
+    child[concept color=red] { node[concept] {technical} }
+    child[concept color=orange] { node[concept] {theoretical} };
+  {tikz}
+  </td>
+</tr>
+
+<tr>
+  <td>
+  Transparent and high res
+  <pre>
+  \{tikz:: {path: mindmap-low.png, libraries: [mindmap],
+     img_attr: {style: 'background:transparent'},
+     transparent: true, resolution: 300 72}}
+  \path[mindmap,concept color=black,text=white]
+    node[concept] {Computer Science}
+    [clockwise from=0]
+    child[concept color=red] { node[concept] {technical} }
+    child[concept color=orange] { node[concept] {theoretical} };
+  {tikz}
+  </pre>
+  </td>
+  <td>
+  {tikz:: {path: mindmap-high.png, libraries: [mindmap],
+    img_attr: {style: 'background:transparent'},
+    transparent: true, resolution: 300 72}}
+  \path[mindmap,concept color=black,text=white]
+    node[concept] {Computer Science}
+    [clockwise from=0]
+    child[concept color=red] { node[concept] {technical} }
+    child[concept color=orange] { node[concept] {theoretical} };
+  {tikz}
+  </td>
+</tr>
+
+</table>

data/lib/webgen/common/sitemap.rb

@@ -1,4 +1,4 @@
-require 'webgen/tag/menu'
+require 'webgen/tag'
 require 'webgen/websiteaccess'
 
 module Webgen::Common
@@ -64,13 +64,12 @@ module Webgen::Common
             (tree.flatten.any? do |alcn|
                (n = node.tree[alcn]) && (r = n.routing_node(lang)) && r.meta_info_changed?
              end)
-          node.dirty = true
+          node.flag(:dirty)
           break
         end
       end
     end
 
-
   end
 
 end

data/lib/webgen/contentprocessor/blocks.rb

@@ -1,5 +1,3 @@
-require 'webgen/loggable'
-
 module Webgen::ContentProcessor
 
   # Replaces special xml tags with the rendered content of a node.

data/lib/webgen/contentprocessor/context.rb

@@ -1,6 +1,3 @@
-require 'webgen/contentprocessor'
-require 'webgen/websiteaccess'
-
 module Webgen::ContentProcessor
 
   # The context object that is passed to the +call+ method of a content processor.

data/lib/webgen/contentprocessor/erubis.rb

@@ -1,5 +1,3 @@
-require 'webgen/websiteaccess'
-
 module Webgen::ContentProcessor
 
   # Processes embedded Ruby statements with the +erubis+ library.

data/lib/webgen/default_config.rb

@@ -54,7 +54,7 @@ config.sourcehandler.patterns({
                                 'Webgen::SourceHandler::Sitemap' => ['**/*.sitemap']
                               }, :doc => 'Source handler to path pattern map')
 config.sourcehandler.invoke({
-                              1 => ['Webgen::SourceHandler::Directory', 'Webgen::SourceHandler::Metainfo', 'Webgen::SourceHandler::Directory'],
+                              1 => ['Webgen::SourceHandler::Directory', 'Webgen::SourceHandler::Metainfo'],
                               5 => ['Webgen::SourceHandler::Copy', 'Webgen::SourceHandler::Template',
                                     'Webgen::SourceHandler::Page', 'Webgen::SourceHandler::Feed',
                                     'Webgen::SourceHandler::Sitemap'],
@@ -148,6 +148,7 @@ config.contentprocessor.tags.map({
                                    'coderay' => 'Webgen::Tag::Coderay',
                                    'date' => 'Webgen::Tag::Date',
                                    'sitemap' => 'Webgen::Tag::Sitemap',
+                                   'tikz' => 'Webgen::Tag::TikZ',
                                    :default => 'Webgen::Tag::Metainfo'
                                  }, :doc => 'Tag processor name to class map')
 
@@ -190,6 +191,12 @@ config.tag.coderay.tab_width(8, :doc => 'Number of spaces used for a tabulator')
 
 config.tag.date.format('%Y-%m-%d %H:%M:%S', :doc => 'The format of the date (same options as Ruby\'s Time#strftime)')
 
+config.tag.tikz.path(nil, :doc => 'The source path of the created image', :mandatory => 'default')
+config.tag.tikz.libraries(nil, :doc => 'An array of additional TikZ library names')
+config.tag.tikz.opts(nil, :doc => 'A string with global options for the tikzpicture environment')
+config.tag.tikz.resolution('72 72', :doc => 'A string specifying the render and output resolutions')
+config.tag.tikz.transparent(false, :doc => 'Specifies whether the generated image should be transparent (only png)')
+config.tag.tikz.img_attr({}, :doc => 'A hash of additional HTML attributes for the created img tag')
 
 # All things regarding common functionality
 website.autoload_service(:create_sitemap, 'Webgen::Common::Sitemap')

data/lib/webgen/node.rb

@@ -46,17 +46,6 @@ module Webgen
     # Meta information associated with the node.
     attr_reader :meta_info
 
-    # Set by other objects to +true+ if they think the object has changed since the last run. Must
-    # not be set to +false+ once it is +true+!
-    attr_accessor :dirty
-
-    # Set by other objects to +true+ if the meta information of the node has changed since the last
-    # run. Must not be set to +false+ once it is +true+!
-    attr_accessor :dirty_meta_info
-
-    # Has the node been created or has it been read from the cache?
-    attr_accessor :created
-
     # Create a new Node instance.
     #
     # +parent+ (immutable)::
@@ -78,15 +67,27 @@ module Webgen
     # found, the node is language neutral.
     def initialize(parent, path, cn, meta_info = {})
       @parent = parent
-      @path = path.freeze
       @cn = cn.chomp('/').freeze
+      @children = []
+      reinit(path, meta_info)
+      init_rest
+    end
+
+    # Re-initializes an already initialized node and resets it to its pristine state.
+    def reinit(path, meta_info = {})
+      old_path = @path
+      @path = path.freeze
       @lang = meta_info.delete('lang').freeze
       @lang = nil unless is_file?
       @meta_info = meta_info
-      @children = []
-      @dirty = true
-      @created = true
-      init_rest
+      @flags = Set.new([:dirty, :created])
+      if @tree
+        @tree.node_access[:path].delete(old_path) if old_path
+        @tree.register_path(self)
+        self.node_info.clear
+        self.node_info[:used_nodes] = Set.new
+        self.node_info[:used_meta_info_nodes] = Set.new
+      end
     end
 
     # Return the meta information item for +key+.
@@ -116,26 +117,50 @@ module Webgen
     # Check if the node is the root node.
     def is_root?; self == tree.root;  end
 
+    # Check if the node is flagged with one of the following:
+    #
+    # :created:: Has the node been created or has it been read from the cache?
+    # :reinit:: Does the node need to be reinitialized?
+    # :dirty:: Set by other objects to +true+ if they think the object has changed since the last
+    #          run. Must not be set to +false+ once it is +true+!
+    # :dirty_meta_info:: Set by other objects to +true+ if the meta information of the node has
+    #                    changed since the last run. Must not be set to +false+ once it is +true+!
+    def flagged(key)
+      @flags.include?(key)
+    end
+
+    # Flag the node with the +keys+. See #flagged for valid keys.
+    def flag(*keys)
+      @flags += keys
+      website.blackboard.dispatch_msg(:node_flagged, self, keys)
+    end
+
+    # Remove the flags +keys+ from the node.
+    def unflag(*keys)
+      @flags.subtract(keys)
+      website.blackboard.dispatch_msg(:node_unflagged, self, keys)
+    end
+
     # Return +true+ if the node has changed since the last webgen run. If it has changed, +dirty+ is
     # set to +true+.
     def changed?
       if_not_checked(:node) do
-        @dirty = @dirty || meta_info_changed?
-        @dirty = node_info[:used_nodes].any? {|n| n != @absolute_lcn && (!tree[n] || tree[n].changed?)} unless @dirty
-        website.blackboard.dispatch_msg(:node_changed?, self) unless @dirty
+        flag(:dirty) if meta_info_changed? ||
+          node_info[:used_nodes].any? {|n| n != @absolute_lcn && (!tree[n] || tree[n].changed?)}
+        website.blackboard.dispatch_msg(:node_changed?, self) unless flagged(:dirty)
       end
-      @dirty
+      flagged(:dirty)
     end
 
     # Return +true+ if the meta information of the node has changed.
     def meta_info_changed?
       if_not_checked(:meta_info) do
-        @dirty_meta_info = node_info[:used_meta_info_nodes].any? do |n|
+        flag(:dirty_meta_info) if node_info[:used_meta_info_nodes].any? do |n|
           n != @absolute_lcn && (!tree[n] || tree[n].meta_info_changed?)
-        end unless @dirty_meta_info
-        website.blackboard.dispatch_msg(:node_meta_info_changed?, self) unless @dirty_meta_info
+        end
+        website.blackboard.dispatch_msg(:node_meta_info_changed?, self) unless flagged(:dirty_meta_info)
       end
-      @dirty_meta_info
+      flagged(:dirty_meta_info)
     end
 
     # Return an informative representation of the node.

data/lib/webgen/page.rb

@@ -55,14 +55,17 @@ module Webgen
       # the information. The +meta_info+ parameter can be used to provide default meta information.
       def from_data(data, meta_info = {})
         md = /(#{RE_META_INFO})?(.*)/m.match(normalize_eol(data))
-        if md[1].nil? && data =~ RE_META_INFO_START
-          raise WebgenPageFormatError, 'Found start line for meta information block but no valid meta information block'
-        end
-        meta_info = meta_info.merge(md[1].nil? ? {} : parse_meta_info(md[1]))
+        meta_info = meta_info.merge(parse_meta_info(md[1], data))
         blocks = parse_blocks(md[2] || '', meta_info)
         new(meta_info, blocks)
       end
 
+      # Parse the given string +data+ in Webgen Page Format and return the found meta information.
+      def meta_info_from_data(data)
+        md = /(#{RE_META_INFO})?/m.match(normalize_eol(data))
+        parse_meta_info(md[1], data)
+      end
+
       #######
       private
       #######
@@ -72,17 +75,24 @@ module Webgen
         data.gsub(/\r\n?/, "\n")
       end
 
-      # Parse the meta info string +data+ and return the hash with the meta information.
-      def parse_meta_info(data)
-        begin
-          meta_info = YAML::load(data)
-          unless meta_info.kind_of?(Hash)
-            raise WebgenPageFormatError, "Invalid structure of meta information block: expected YAML hash but found #{meta_info.class}"
+      # Parse the meta info string in +mi_data+ and return the hash with the meta information. The
+      # original +data+ is used for checking the validness of the meta information block.
+      def parse_meta_info(mi_data, data)
+        if mi_data.nil? && data =~ RE_META_INFO_START
+          raise WebgenPageFormatError, 'Found start line for meta information block but no valid meta information block'
+        elsif mi_data.nil?
+          {}
+        else
+          begin
+            meta_info = YAML::load(mi_data.to_s)
+            unless meta_info.kind_of?(Hash)
+              raise WebgenPageFormatError, "Invalid structure of meta information block: expected YAML hash but found #{meta_info.class}"
+            end
+          rescue ArgumentError => e
+            raise WebgenPageFormatError, e.message
           end
-        rescue ArgumentError => e
-          raise WebgenPageFormatError, e.message
+          meta_info
         end
-        meta_info
       end
 
       # Parse all blocks in +data+ and return them. Meta information can be provided in +meta_info+
@@ -118,12 +128,12 @@ module Webgen
     # The contents of the meta information block.
     attr_reader :meta_info
 
-    # The array of blocks for the page.
+    # The hash of blocks for the page.
     attr_reader :blocks
 
     # Create a new Page object with the meta information provided in +meta_info+ and the given
     # +blocks+.
-    def initialize(meta_info = {}, blocks = nil)
+    def initialize(meta_info = {}, blocks = {})
       @meta_info = meta_info
       @blocks = blocks
     end

data/lib/webgen/path.rb

@@ -35,11 +35,24 @@ module Webgen
     end
 
 
+    # Return +true+ if the given +path+ matches the given +pattern+ (trailing slashes of directories
+    # are not respected). For information on which patterns are supported, have a look at the
+    # documentation of File.fnmatch.
+    def self.match(path, pattern)
+      path = path.to_s.chomp('/') unless path == '/'
+      pattern = pattern.to_s.chomp('/') unless pattern == '/'
+      File.fnmatch(pattern, path, File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
+    end
+
+
     include Comparable
 
-    # The full source path.
+    # The full path.
     attr_accessor :path
 
+    # The source path that lead to the creation of this path.
+    attr_accessor :source_path
+
     # The basename part of the path.
     attr_accessor :basename
 
@@ -55,11 +68,13 @@ module Webgen
     # Extracted meta information for the path.
     attr_accessor :meta_info
 
-    # Create a new Path object for +path+. The optional block needs to return an IO object for the
-    # content of the path.
-    def initialize(path, &ioblock)
+    # Create a new Path object for +path+. The optional +source_path+ parameter specifies the path
+    # that lead to the creation of this path. The optional block needs to return an IO object for
+    # the content of the path.
+    def initialize(path, source_path = path, &ioblock)
       @meta_info = {}
       @io = SourceIO.new(&ioblock) if block_given?
+      @source_path = source_path
       analyse(path)
     end
 
@@ -70,6 +85,7 @@ module Webgen
       temp.path = temp.path.sub(/^#{Regexp.escape(prefix.chomp("/"))}/, '') if prefix     #"
       reanalyse = (@path == '/' || temp.path == '/')
       temp.path = File.join(mp, temp.path)
+      temp.source_path = temp.path if @path == @source_path
       if reanalyse
         temp.send(:analyse, temp.path)
       else
@@ -131,12 +147,6 @@ module Webgen
     end
     alias_method(:eql?, :==)
 
-    # Return +true+ if the localized path matches the given +pattern+. For information on which
-    # patterns are supported, have a look at the documentation of File.fnmatch.
-    def =~(pattern)
-      File.fnmatch(pattern, File.join(@directory, lcn), File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
-    end
-
     # Implemented sothat a Path looks like a String when used as key in a hash.
     def <=>(other)
       @path <=> other.to_str

data/lib/webgen/sourcehandler/base.rb

@@ -42,9 +42,18 @@ module Webgen::SourceHandler
   # <tt>node_info[:processor]</tt>:: Has to be set to the class name of the source handler. This is
   #                                  used by the Node class: all unknown method calls are forwarded
   #                                  to the node processor.
-  # <tt>node_info[:src]</tt>:: Has to be set to the string version of the source path.
+  # <tt>node_info[:src]</tt>:: Has to be set to the string version of the path that lead to the
+  #                            creation of the node.
+  # <tt>node_info[:creation_path]</tt>:: Has to be set to the string version of the path that is
+  #                                      used to create the path.
   # <tt>meta_info['no_output']</tt>:: Has to be set to +true+ on nodes that are used during a
   #                                   webgen run but do not produce an output file.
+  # <tt>meta_info['modified_at']</tt>:: Is automatically set to the current time if not already set
+  #                                     correctly (ie. if not a Time object).
+  #
+  # Note: The difference between +:src+ and +:creation_path+ is that a creation path need not have
+  # an existing source path representation. For example, fragments created from a page source path
+  # have a different +:creation_path+ which includes the fragment part.
   #
   # Additional information that is used only for processing purposes should be stored in the
   # #node_info hash of a node as the #meta_info hash is reserved for real node meta information and
@@ -55,7 +64,8 @@ module Webgen::SourceHandler
   # Path patterns define which paths are handled by a specific source handler. These patterns are
   # specified in the <tt>sourcehandler.patterns</tt> configuration hash as a mapping from the source
   # handler class name to an array of path patterns. The patterns need to have a format that
-  # <tt>Dir.glob</tt> can handle.
+  # <tt>Dir.glob</tt> can handle. You can use the configuration helper +patterns+ to set this (is
+  # shown in the example below).
   #
   # Specifying a path pattern does not mean that webgen uses the source handler. One also needs to
   # provide an entry in the configuration value <tt>sourcehandler.invoke</tt>. This is a hash that
@@ -97,7 +107,7 @@ module Webgen::SourceHandler
   #
   #   end
   #
-  #   WebsiteAccess.website.config.sourcehandler.patterns['SimpleCopy'] = ['**/*.jpg', '**/*.png']
+  #   WebsiteAccess.website.config.patterns('SimpleCopy' => ['**/*.jpg', '**/*.png'])
   #   WebsiteAccess.website.config.sourcehandler.invoke[5] << 'SimpleCopy'
   #
   module Base
@@ -156,7 +166,9 @@ module Webgen::SourceHandler
       if OutputPathHelpers.public_instance_methods(false).include?(method)
         name = send(method, parent, path, use_lang_part)
         name += '/'  if path.path =~ /\/$/ && name !~ /\/$/
-        if node_exists?(parent, path, name)
+        if (node = node_exists?(parent, path, name)) && node.lang == path.meta_info['lang']
+          name = node.path
+        elsif node
           name = send(method, parent, path, (path.meta_info['lang'].nil? ? false : true))
           name += '/'  if path.path =~ /\/$/ && name !~ /\/$/
         end
@@ -172,21 +184,31 @@ module Webgen::SourceHandler
       parent.tree[Webgen::Node.absolute_name(parent, path.lcn, :alcn)] || (!path.meta_info['no_output'] && parent.tree[output_path, :path])
     end
 
-    # Create and return a node under +parent+ from +path+ if it does not already exists. Some
+    # Create a node under +parent+ from +path+ if it does not already exists or needs to be
+    # re-initialized. The found node or the newly created node is returned afterwards. +nil+ is
+    # returned if no node can be created (e.g. when <tt>path.meta_info['draft']</tt> is set). Some
     # additional node information like <tt>:src</tt> and <tt>:processor</tt> is set and the meta
-    # information is checked for validness. The created node is yielded if a block is given.
+    # information is checked for validness. The created/re-initialized node is yielded if a block is
+    # given.
     def create_node(parent, path, output_path = self.output_path(parent, path))
-      return if path.meta_info['draft']
-      if !node_exists?(parent, path, output_path)
+      return nil if path.meta_info['draft']
+      node = node_exists?(parent, path, output_path)
+      if node && (node.node_info[:src] != path.source_path || node.node_info[:processor] != self.class.name)
+        log(:warn) { "Node already exists: source = #{path.source_path} | path = #{node.path} | alcn = #{node.absolute_lcn}"}
+        return node
+      elsif !node
         node = Webgen::Node.new(parent, output_path, path.cn, path.meta_info)
-        node['modified_at'] = Time.now unless node['modified_at'].kind_of?(Time)
-        node.node_info[:src] = path.path
-        node.node_info[:processor] = self.class.name
-        yield(node) if block_given?
-        node
+      elsif node.flagged(:reinit)
+        node.reinit(output_path, path.meta_info)
       else
-        log(:warn) { "Node already exists: output path = #{output_path} | alcn = #{Webgen::Node.absolute_name(parent, path.lcn, :alcn)}"}
+        return node
       end
+      node['modified_at'] = Time.now unless node['modified_at'].kind_of?(Time)
+      node.node_info[:src] = path.source_path
+      node.node_info[:creation_path] = path.path
+      node.node_info[:processor] = self.class.name
+      yield(node) if block_given?
+      node
     end
 
     # Return the content of the given +node+. This default +content+ method just returns +nil+.