webgen 0.3.8 → 0.4.0

data/lib/webgen/composite.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: composite.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: composite.rb 402 2006-04-07 15:21:41Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -45,16 +45,16 @@ module Composite
 
   # Returns the array of children
   def children
-    @children = [] unless defined? @children
+    @children = [] unless defined?( @children )
     @children
   end
 
 
   # Adds all objects in the array
   def add_children( array )
-    if array.kind_of? Array
-      @children = [] unless defined? @children
-      @children.concat array
+    if array.kind_of?( Array )
+      @children = [] unless defined?( @children )
+      @children.concat( array.compact )
     else
       raise ArgumentError, "Parameter must be array"
     end
@@ -69,8 +69,8 @@ module Composite
 
   # Adds the child
   def add_child( child )
-    @children = [] unless defined? @children
-    @children.push child unless @children.include? child
+    @children = [] unless defined?( @children )
+    @children.push( child ) unless child.nil? || @children.include?( child )
   end
 
 
@@ -79,17 +79,17 @@ module Composite
   # [+Numeric+] the child at the specified position is deleted
   # [+else+]    the specified child is deleted
   def del_child( child )
-    if child.kind_of? Numeric
-      @children.delete_at child if defined? @children
+    if child.kind_of?( Numeric )
+      @children.delete_at( child ) if defined?( @children )
     else
-      @children.delete child if defined? @children
+      @children.delete( child ) if defined?( @children )
     end
   end
 
 
   # Iterates over all childrenldren
   def each   # :yields: child
-    children.each do |child| yield child end if defined? @children
+    @children.each {|child| yield child } if defined?( @children )
   end
 
 

data/lib/webgen/config.rb

@@ -0,0 +1,52 @@
+#
+#--
+#
+# $Id: config.rb 531 2006-11-17 17:56:14Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'rbconfig'
+
+module Webgen
+
+  VERSION = [0, 4, 0]
+  AUTHOR = 'Thomas Leitner <t_leitner@gmx.at>'
+  SUMMARY = "webgen is a templated based static Web site generator."
+  DESCRIPTION = "webgen is a Web site generator implemented in Ruby. " \
+  "It is used to generate static Web pages from templates and page " \
+  "description files."
+
+  # The directory below a website directory in which the source files are.
+  SRC_DIR = 'src'
+
+  # The directory below a website directory in which the plugin files are.
+  PLUGIN_DIR = 'plugin'
+
+  # Returns the data directory for webgen.
+  def self.data_dir
+    unless defined?( @@data_dir )
+      @@data_dir = File.join( Config::CONFIG["datadir"], "webgen" )
+
+      @@data_dir =  File.join( File.dirname( __FILE__ ), '..', '..', 'data', 'webgen') if !File.exists?( @@data_dir )
+
+      raise "Could not find webgen data directory! This is a bug, report it please!" unless File.directory?( @@data_dir )
+    end
+    @@data_dir
+  end
+
+end

data/lib/webgen/content.rb

@@ -0,0 +1,172 @@
+#
+#--
+#
+# $Id: content.rb 576 2007-01-03 19:41:12Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'yaml'
+require 'erb'
+
+# A single block within a page file. The content of the block gets automatically parsed for HTML
+# headers with the id attribute set and converts them into sections for later use.
+class HtmlBlock
+
+  # A section with a block. Corresponds to an HTML header with an id.
+  class Section
+
+    # The level of the header, ie. 1 for a h1 tag, 2, for a h2 tag, and so on.
+    attr_reader :level
+
+    # The id of the tag.
+    attr_reader :id
+
+    # The title of the tag, ie. the content between the opening and closing h[123456] tag.
+    attr_reader :title
+
+    # Sub sections of this section.
+    attr_accessor :subsections
+
+    # Creates a new Section object with the given +level+, +id+, and +title+.
+    def initialize( level, id, title )
+      @level, @id, @title = level, id, title
+      @subsections = []
+    end
+
+  end
+
+  # The name of the block.
+  attr_reader :name
+
+  # The content of the block.
+  attr_reader :content
+
+  # The parsed sections as array of Section objects.
+  attr_reader :sections
+
+  # Creates a new block with the name +name+ and the given +content+. The content gets parsed for
+  # sections automatically.
+  def initialize( name, content )
+    @name, @content = name, content
+    @sections = self.class.parse_sections( content )
+  end
+
+  # Renders the block using ERB and +context+ as binding.
+  def render_with_erb( context )
+    @compiled_block = ERB.new( @content ) unless defined?( @compiled_block )
+    @compiled_block.result( context )
+  end
+
+  #######
+  private
+  #######
+
+  SECTION_REGEXP = /<h([123456])(?:>|\s([^>]*)>)(.*?)<\/h\1\s*>/i
+  ATTR_REGEXP = /\s*(\w+)\s*=\s*('|")([^\2]+)\2\s*/
+
+  def self.parse_sections( content )
+    sections = []
+    stack = []
+    content.scan( SECTION_REGEXP ).each do |level,attrs,title|
+      next if attrs.nil?
+      id_attr = attrs.scan( ATTR_REGEXP ).find {|name,sep,value| name == 'id'}
+      next if id_attr.nil?
+      id = id_attr[2]
+
+      section = Section.new( level.to_i, id, title )
+      success = false
+      while !success
+        if stack.empty?
+          sections << section
+          stack << section
+          success = true
+        elsif stack.last.level < section.level
+          stack.last.subsections << section
+          stack << section
+          success = true
+        else
+          stack.pop
+        end
+      end
+    end
+    sections
+  end
+
+end
+
+
+# Raised when during parsing of data in the WebPage Description Format if the data is invalid.
+class WebPageDataInvalid < RuntimeError; end
+
+
+# A WebPageData object contains the parsed data of a file/string in the WebPage Description Format.
+class WebPageData
+
+  # The content blocks. Access via index or name.
+  attr_reader :blocks
+
+  # The contents of the meta information block.
+  attr_reader :meta_info
+
+  # Parses the given String +data+ and initializes a new WebPageData object with the found values.
+  # The blocks are converted to HTML by using the provided +formatters+ hash. A key in this hash has
+  # to be a format name and the value and object which responds to the +call(content)+ method. You
+  # can set +default_meta_info+ to provide default entries for the meta information block.
+  def initialize( data, formatters = {'default' => proc {|c| c} }, default_meta_info = {} )
+    @meta_info = default_meta_info
+    @formatters = formatters
+    parse( data )
+  end
+
+  #######
+  private
+  #######
+
+  def parse( data )
+    @blocks = {}
+    blocks = data.scan( /(?:(?:^--- *(?:(\w+) *(?:, *(\w+) *)?)?$)|\A)(.*?)(?:(?=^---.*?$)|\Z)/m )
+    if data =~ /\A---\s*$/
+      begin
+        meta = YAML::load( blocks.shift[2] )
+        raise( WebPageDataInvalid, 'Invalid structure of meta information part') unless meta.kind_of?( Hash )
+        @meta_info.update( meta )
+      rescue ArgumentError => e
+        raise WebPageDataInvalid, e.message
+      end
+    end
+
+    raise( WebPageDataInvalid, 'No content blocks specified' ) if blocks.length == 0
+
+    blocks.each_with_index do |block_data, index|
+      name, format, content = *block_data
+      name = name || (@meta_info['blocks'] && @meta_info['blocks'][index] && @meta_info['blocks'][index][0]) || 'content'
+      raise( WebPageDataInvalid, "Same name used for more than one block: #{name}" ) if @blocks.has_key?( name )
+      content ||= ''
+      content.gsub!( /^(\\+)(---.*?)$/ ) {|m| "\\" * ($1.length / 2) + $2 }
+      content.strip!
+      format = format || (@meta_info['blocks'] && @meta_info['blocks'][index] && @meta_info['blocks'][index][1]) || 'default'
+      @blocks[name] = @blocks[index] = HtmlBlock.new( name, convert( content, format ) )
+    end
+  end
+
+  def convert( content, format )
+    raise( WebPageDataInvalid, "Invalid content format specified: #{format}" ) unless @formatters.has_key?( format )
+    @formatters[format].call( content )
+  end
+
+end

data/lib/webgen/extcommand.rb

@@ -0,0 +1,23 @@
+require "tempfile"
+
+# Allows one to get stdout and stderr from an executed command. Original version
+# by Karl von Laudermann in ruby-talk #113035
+class ExtendedCommand
+
+  attr_reader :ret_code, :out_text, :err_text
+
+  def initialize( command )
+    tempfile = Tempfile.new( 'webgen' )
+    tempfile.close  # So that child process can write to it
+
+    # Execute command, redirecting stderr to temp file
+    @out_text = `#{command} 2> #{tempfile.path}`
+    @ret_code = $? >> 8
+
+    # Read temp file
+    tempfile.open
+    @err_text = tempfile.readlines.join
+    tempfile.close
+  end
+
+end

data/lib/webgen/languages.rb

@@ -0,0 +1,110 @@
+#
+#--
+#
+# $Id: languages.rb 484 2006-09-02 07:55:59Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'webgen/config'
+
+module Webgen
+
+  # Describes a human language which is uniquely identfied by a three letter code and, optionally,
+  # by an alternative three letter or a two letter code.
+  class Language
+
+    include Comparable
+
+    attr_reader :codes
+    attr_reader :description
+
+    # Creates a new language. +codes+ has to be an array containing three strings: the three letter
+    # code, the alternative three letter code and the two letter code. If one is not available for
+    # the language, it has to be +nil+.
+    def initialize( codes, description )
+      @codes = codes
+      @description = description
+    end
+
+    # The two letter code.
+    def code2chars
+      @codes[2]
+    end
+
+    # The three letter code.
+    def code3chars
+      @codes[0]
+    end
+
+    # The alternative three letter code.
+    def code3chars_alternative
+      @codes[1]
+    end
+
+    # The textual representation of the language.
+    def to_s
+      code2chars || code3chars
+    end
+
+    alias_method :to_str, :to_s
+
+    def inspect
+      "#<Language codes=#{codes.inspect} description=#{description.inspect}"
+    end
+
+    def <=>( other )
+      self.to_s <=> other.to_s
+    end
+
+  end
+
+
+  # Used for managinging human languages.
+  module LanguageManager
+
+    # Returns a +Language+ object for the given language code.
+    def self.language_for_code( code )
+      languages[code]
+    end
+
+    # Returns an array of +Language+ objects whose description match the given +text+.
+    def self.find_language( text )
+      languages.values.find_all {|lang| /.*#{Regexp.escape(text)}.*/i =~ lang.description}.uniq.sort
+    end
+
+    # Returns all available languages as a Hash. The keys are the language codes and the values are
+    # the +Language+ objects for them.
+    def self.languages
+      unless defined?( @@languages )
+        @@languages = {}
+        code_file = File.join( Webgen.data_dir, 'data', 'ISO-639-2_values_8bits.txt' )
+        File.readlines( code_file ).each do |l|
+          data = l.chomp.split( '|' ).collect {|f| f.empty? ? nil : f }
+          lang = Language.new( data[0..2], data[3] )
+          @@languages[lang.code2chars] ||= lang unless lang.code2chars.nil?
+          @@languages[lang.code3chars] ||= lang unless lang.code3chars.nil?
+          @@languages[lang.code3chars_alternative] ||= lang unless lang.code3chars_alternative.nil?
+        end
+        @@languages.freeze
+      end
+      @@languages
+    end
+
+  end
+
+end

data/lib/webgen/listener.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: listener.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: listener.rb 271 2005-05-09 08:50:47Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner

data/lib/webgen/node.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: node.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: node.rb 576 2007-01-03 19:41:12Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -21,179 +21,251 @@
 #
 
 require 'uri'
+require 'pathname'
 require 'webgen/composite'
 
+# The Node class is used for building the internal data structure which represents the output tree.
 class Node
 
   include Composite
 
-  attr_reader   :parent
-  attr_accessor :metainfo
+  # The parent node.
+  attr_reader :parent
 
-  def initialize( parent )
-    @parent = parent
-    @metainfo = Hash.new
+  # The path of this node.
+  attr_reader :path
+
+  # Information used for processing the node.
+  attr_accessor :node_info
+
+  # Meta information associated with the node.
+  attr_accessor :meta_info
+
+  # Initializes a new Node instance.
+  #
+  # +parent+::
+  #    if this parameter is +nil+, then the new node acts as root. Otherwise, +parent+ has to
+  #    be a valid node instance.
+  # +path+::
+  #    The path for this node. If this node is a directory, the path must have a trailing
+  #    slash ('dir/'). If it is a fragment, the hash sign must be the first character of the
+  #    path ('#fragment'). A compound path like 'dir/file#fragment' is also allowed as are
+  #    absolute paths like 'http://myhost.com/'.
+  #
+  #    Note: a compound path like 'dir/file' is invalid if the parent node already has a child
+  #    with path 'dir/'!!! (solution: just create a node with path 'file' and node 'dir/' as parent!)
+  def initialize( parent, path )
+    @parent = nil
+    @path = path
+    self.parent = parent
+    @node_info = Hash.new
+    @meta_info = Hash.new
+  end
+
+  # Returns the root node for +node+.
+  def self.root( node )
+    node = node.parent until node.parent.nil?
+    node
+  end
+
+  # Sets a new parent for the node.
+  def parent=( var )
+    @parent.del_child( self ) unless @parent.nil?
+    @parent = var
+    @parent.add_child( self ) unless @parent.nil?
+    precalc_with_children!
+  end
+
+  # Sets the path for the node.
+  def path=( path )
+    @path = path
+    precalc!
   end
 
-  # Get object +name+ from +metainfo+.
+  # Gets object +name+ from +meta_info+.
   def []( name )
-    @metainfo[name]
+    @meta_info[name]
   end
 
-  # Assign +value+ to +metainfo+ called +name.
+  # Assigns +value+ to +meta_info+ called +name.
   def []=( name, value )
-    @metainfo[name] = value
+    @meta_info[name] = value
   end
 
-  # Get the recursive value for metainfo +name+. +ignoreVirtual+ specifies if virtual nodes should
-  # not be appended, but they are traversed nonetheless.
-  def recursive_value( name, ignoreVirtual = true )
-    value = ignoreVirtual && @metainfo['virtual'] ? '' : @metainfo[name]
-    if value.nil?
-      value = ''
-      self.logger.warn { "No meta information called '#{name}' for <#{metainfo['src']}>" }
-    end
-    @parent.nil? ? value : @parent.recursive_value( name, ignoreVirtual ) + value
-  end
+  # Regexp for matching absolute URLs, ie. URLs with a scheme part (also see RFC1738)
+  ABSOLUTE_URL = /^\w[a-zA-Z0-9+.-]*:/
 
+  # Returns the full path for this node. See also Node#absolute_path !
+  def full_path
+    return @precalc[:full_path] if @precalc
 
-  # Returns the relative path from this node to +dest+.
-  def relpath_to_string( dest )
-    if dest[0] == ?/
-      from = recursive_value( 'dest' ).sub( /#{self['dest']}$/, '' ).split( '/' )[1..-1] || []
-      from.fill( '..' )
-      from.concat( dest.split( '/' )[1..-1] ).join( '/' )
+    if @path =~ ABSOLUTE_URL
+      @path
     else
-      from = recursive_value( 'dest' ).sub( /#{self['dest']}$/, '' ).split( '/' )[1..-1] || []
-      from.concat( dest.split( '/' ) ).join( '/' )
+      (@parent.nil? ? @path : @parent.full_path + @path)
     end
   end
 
-  # Return the relative path from this node to the destNode, virtual nodes are not used in the
-  # calculation. The destNode can be any non virtual node. If +destNode+ starts with http://, the
-  # relative path to it is the empty string. If +includeDestNode+ is true, then the path of the
-  # destination node is appended to the calculated path.
-  def relpath_to_node( destNode, includeDestNode = true)
-    if URI::parse( destNode['dest'] ).absolute?
-      path = destNode['dest']
+  # Returns the absolute path, ie. starting with a slash for the root directory, for this node.
+  #
+  # Here is an example that shows the difference between +full_path+ and +absolute_path+:
+  #
+  #   root = Node.new( nil, '../output/' )
+  #   dir = Node.new( root, 'testdir/' )
+  #   node = Node.new( dir, 'testfile' )
+  #   node.full_path # => '../output/testdir/testfile'
+  #   node.absolute_path # => '/testdir/testfile'
+  def absolute_path
+    return @precalc[:absolute_path] if @precalc
+
+    if @path =~ ABSOLUTE_URL
+      @path
     else
-      from = recursive_value( 'dest' ).sub( /#{self['dest']}$/, '' ).split( '/' )[1..-1] || []
-      to = destNode.recursive_value( 'dest' ).sub( /#{destNode['dest']}$/, '' ).split( '/' )[1..-1] || []
-
-      while from.size > 0 and to.size > 0 and from[0] == to[0]
-        from.shift
-        to.shift
-      end
-
-      from.fill( '..' )
-      from.concat( to )
-      path = ( from.length == 0 ? '.' : from.join( '/' ) )
-      path += '/' + destNode['dest'] if includeDestNode && !destNode.parent.nil?
+      full_path.sub( /^#{Node.root( self ).path}/, '/' )
     end
-    path
   end
 
+  # Returns the level of the node. The level specifies how deep the node is in the hierarchy.
+  def level
+    (@parent.nil? ? 0 : @parent.level + 1)
+  end
 
-  # Return the node identified by +destString+ relative to the current node.
-  def node_for_string( destString, metainfo='dest' )
-    node = get_node_for_string( destString, metainfo )
-    if node.nil?
-      self.logger.warn { "Could not get destination node '#{destString}' for <#{recursive_value( 'src' )}>" }
-    end
-    node
+  # Checks if the node is a directory.
+  def is_directory?
+    @path[-1] == ?/
   end
 
-  # Check if there is a node for +destString+.
-  def node_for_string?( destString, metainfo='dest' )
-    get_node_for_string( destString, metainfo )
+  # Checks if the node is a file.
+  def is_file?
+    !is_directory? && !is_fragment?
   end
 
-  # Return the level of the node. The level specifies how deep the node is in the hierarchy.
-  def level( ignoreVirtual = true )
-    if self.parent.nil?
-      1
-    else
-      self.parent.level( ignoreVirtual ) \
-      + ( (@metainfo['virtual'] && ignoreVirtual) || (@metainfo['dest'] !~ /\/$/) ? 0 : 1 )
+  # Checks if the node is a fragment.
+  def is_fragment?
+    @path[0] == ?#
+  end
+
+  # Matches the path of the node against the given path at the beginning. Returns the
+  # matched portion or +nil+. Used by #resolve_node.
+  def =~( path )
+    md = if is_directory?
+           /^#{@path.chomp('/')}(\/|$)/ =~ path                  #' #emacs hack
+         elsif is_fragment?
+           /^#{@path}$/ =~ path
+         else
+           /^#{@path}(?=#|$)/ =~ path
+         end
+    if md then $& end
+  end
+
+  # Returns the value of the meta info +orderInfo+ or +0+ if it is not set.
+  def order_info
+    self['orderInfo'].to_s.to_i         # nil.to_s.to_i => 0
+  end
+
+  # Sorts nodes by using the meta info +orderInfo+ of both involved nodes or, if these values are
+  # equal, by the meta info +title+.
+  def <=>( other )
+    self_oi = self.order_info
+    other_oi = other.order_info
+    (self_oi == other_oi ? (self['title'] || '') <=> (other['title'] || '') : self_oi <=> other_oi)
+  end
+
+  # Returns the route to the given path. The parameter +path+ can be a String or a Node.
+  def route_to( other )
+    my_url = self.to_url
+    other_url = case other
+                when String then my_url + other
+                when Node then other.to_url
+                else raise ArgumentError
+                end
+    # resolve any '.' and '..' paths in the target url
+    if other_url.path =~ /\/\.\.?\// && other_url.scheme == 'webgen'
+      other_url.path = Pathname.new( other_url.path ).cleanpath.to_s
     end
+    route = my_url.route_to( other_url ).to_s
+    (route == '' ? ( self.is_fragment? ? self.parent.path : self.path ) : route )
   end
 
-  # Checks if the current node is in the subtree in which the supplied node is. This is done by
-  # analyzing the paths of the two nodes.
-  def in_subtree?( node )
-    node = node.parent if node.metainfo['dest'] !~ /\/$/
-    node = node.parent while node['virtual']
-    /^#{node.recursive_value( 'dest' )}/ =~ recursive_value( 'dest' )
+  # Checks if the current node is in the subtree which is spanned by the supplied node. The check is
+  # performed using only the +parent+ information of the involved nodes, NOT the actual path values!
+  def in_subtree_of?( node )
+    temp = self
+    temp = temp.parent while !temp.nil? && temp != node
+    !temp.nil?
   end
 
-  # Returns the parent directory for this node. This function ignores virtual directories.
-  def parent_dir
-    node = self.parent
-    node = node.parent while !node.nil? && node['virtual']
+  # Returns the node representing the given +path+. The path can be absolute (i.e. starting with a
+  # slash) or relative to the current node. If no node exists for the given path or it would lie
+  # outside the node tree, +nil+ is returned.
+  def resolve_node( path )
+    url = self.to_url + path
+
+    path = url.path[1..-1].to_s + (url.fragment.nil? ? '' : '#' + url.fragment)
+    return nil if path =~ /^\.\./ || url.scheme != 'webgen' # path outside dest dir or not an internal URL (webgen://...)
+
+    node = Node.root( self )
+
+    match = nil
+    while !node.nil? && !path.empty?
+      node = node.find {|c| match = (c =~ path) }
+      path.sub!( match, '' ) unless node.nil?
+      break if path.empty?
+    end
+
     node
   end
 
-  # Returns the root node for +node+.
-  def self.root( node )
-    node = node.parent until node.parent.nil?
-    node
+  # Returns the full URL (including dummy scheme and host) for use with URI classes. The returned
+  # URL does not include the real path of the root node but a slash instead. So if the full path of
+  # the node is 'a/b/c/d/file1' and the root node path is 'a/b/c', the URL path would be '/d/file1'.
+  def to_url
+    return @precalc[:to_url] if @precalc
+
+    url = URI::parse( absolute_path )
+    url = URI::parse( 'webgen://webgen.localhost/' ) + url unless url.absolute?
+    url
   end
 
   # Returns an informative representation of the node.
-  def to_s
-    "<##{self.class.name}: src=#{@metainfo['src']}, dest=#{@metainfo['dest']}, title=#{@metainfo['title']}>"
+  def inspect
+    "<##{self.class.name}: path=#{full_path}>"
   end
 
+  alias_method :to_s, :full_path
+
   #######
   private
   #######
 
-  def get_node_for_string( destString, metainfo='dest' )
-    return self if destString == ''
-
-    if /^\// =~ destString
-      node = Node.root( self )
-      destString = destString[1..-1]
-    else
-      node = @metainfo['int:directory?'] ? self : self.parent_dir || self
-    end
+  def precalc!
+    @precalc = nil
+    @precalc = {
+      :full_path => full_path,
+      :absolute_path => absolute_path,
+      :to_url => to_url
+    }
+  end
 
-    startElement = node
-    elements = destString.split( '/' )
-    pagelang = (/\.(\w\w\w?)\.page$/ =~ destString ? $1 : Webgen::Plugin['Configuration']['lang'])
-
-    elements.each do |element|
-      break if node.nil?
-      case element
-      when '..' then node = node.parent
-      else
-        node = node.find do |child|
-          /^#{element}\/?$/ =~ child[metainfo] || \
-          (metainfo == 'dest' && (child['int:pagename'] == element || child['int:local-pagename'] == element) && \
-           child['lang'] == pagelang)
-        end
-      end
-    end
+  def precalc_with_children!
+    precalc!
+    each {|child| child.precalc_with_children!}
+  end
+  protected :precalc_with_children!
 
-    # try extended search where child['dest'] can have slashes
-    if node.nil?
-      node = startElement
-      elements.each_with_index do |element, index|
-        break if node.nil?
-        temp = node.find {|child| /^#{elements[index..-1].join( '/' )}\/?$/ =~ child[metainfo]}
-        if temp.nil?
-          case element
-          when '..' then node = node.parent
-          else node = node.find {|child| /^#{element}\/?$/ =~ child[metainfo] }
-          end
-        else
-          node = temp
-          break
-        end
-      end
+  # Delegates missing methods to a processor. The current node is placed into the argument array as
+  # the first argument before the method +name+ is invoked on the processor.
+  def method_missing( name, *args, &block )
+    if @node_info[:processor]
+      @node_info[:processor].send( name, *([self] + args), &block )
+    else
+      super
     end
-
-    node
   end
 
+=begin
+TODO:
+- stable sort which does not switch items that have the same order_info
+=end
+
 end