webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/item_tracker/node_content.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/item_tracker'
+
+module Webgen
+  class ItemTracker
+
+    # This class is used to track changes to the content of a node. The content of a node is changed
+    # if any of its dependencies are changed.
+    #
+    # The item for this tracker is the alcn of the node:
+    #
+    #   website.ext.item_tracker.add(some_node, :node_content, my_node.alcn)
+    #
+    class NodeContent
+
+      def initialize(website) #:nodoc:
+        @website = website
+      end
+
+      def item_id(alcn) #:nodoc:
+        alcn
+      end
+
+      def item_data(alcn) #:nodoc:
+        nil
+      end
+
+      def changed?(alcn, old_data) #:nodoc:
+        @website.tree[alcn].nil? || @website.ext.item_tracker.node_changed?(@website.tree[alcn])
+      end
+
+      def node_referenced?(alcn, nothing, node_alcn) #:nodoc:
+        alcn == node_alcn
+      end
+
+    end
+
+  end
+end

data/lib/webgen/item_tracker/node_meta_info.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/item_tracker'
+
+module Webgen
+  class ItemTracker
+
+    # This class is used to track changes to a node's meta information.
+    #
+    # Depending on what should be tracked, one needs to provide the following item:
+    #
+    # [node_alcn, nil]
+    #   Tracks changes to the whole meta information of the node, i.e. if any meta information value
+    #   changes, a change is detected.
+    #
+    # [node_alcn, key]
+    #   Tracks changes to a specific meta information key of the node.
+    #
+    # Here are some examples:
+    #
+    #   website.ext.item_tracker.add(some_node, :node_meta_info, my_node.alcn) # first case
+    #   website.ext.item_tracker.add(some_node, :node_meta_info, my_node.alcn, 'title') # second case
+    #
+    class NodeMetaInfo
+
+      CONTENT_MODIFICATION_KEY = 'modified_at'
+
+      def initialize(website) #:nodoc:
+        @website = website
+      end
+
+      def item_id(alcn, key = nil) #:nodoc:
+        [alcn, key]
+      end
+
+      def item_data(alcn, key = nil) #:nodoc:
+        mi = @website.tree[alcn].meta_info
+        key.nil? ? (mi = mi.dup; mi.delete(CONTENT_MODIFICATION_KEY); mi) : mi[key].dup
+      end
+
+      def changed?(iid, old_data) #:nodoc:
+        alcn, key = *iid
+        @website.tree[alcn].nil? || item_data(alcn, key) != old_data
+      end
+
+      def node_referenced?(iid, mi, node_alcn) #:nodoc:
+        iid.first == node_alcn
+      end
+
+    end
+
+  end
+end

data/lib/webgen/item_tracker/nodes.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/item_tracker'
+
+module Webgen
+  class ItemTracker
+
+    # This class is used to track changes to a (nested) list of nodes.
+    #
+    # An item for this tracker has to consist of the following fields:
+    #
+    # * An array consisting of [class/module name, method name] or a string/symbol specifying a
+    #   method name
+    # * Options argument (use an array or hash for multiple arguments)
+    # * Either :content or :meta_info, depending on whether the content or the meta info of
+    #   the found nodes should be tracked.
+    #
+    # The list of nodes is retrieved in one of two ways, depending on the type of the first field:
+    #
+    # * If it is a string/symbol, it specifies the name of a method on this class. This method has
+    #   to take the options hash as the only parameter.
+    #
+    # * If it is an array, the array has to contain a class/module name and a method name. The
+    #   method is invoked with the current Webgen::Website object as first and the options hash as
+    #   second parameter.
+    #
+    # For example, consider the following statement:
+    #
+    #   website.ext.item_tracker.add(some_node, :nodes,
+    #     ["MyModule::MyClass", "my_method"], {:some => 'options'}, :content)
+    #
+    # The method will be invoked like this for retrieving the nodes:
+    #
+    #   MyModule::MyClass.my_method(website, {:some => 'options'})
+    #
+    class Nodes
+
+      def initialize(website) #:nodoc:
+        @website = website
+      end
+
+      def item_id(method_name, options, type) #:nodoc:
+        [method_name, options, type]
+      end
+
+      def item_data(method_name, options, type) #:nodoc:
+        nodes_to_alcn(node_list(method_name, options))
+      end
+
+      def changed?(iid, old_data) #:nodoc:
+        method_name, options, type = *iid
+        nodes = node_list(method_name, options)
+        old_data != nodes_to_alcn(nodes) ||
+          nodes.flatten.any? {|n| type == :content ? @website.ext.item_tracker.node_changed?(n) : @website.ext.item_tracker.item_changed?(:node_meta_info, n.alcn)}
+      end
+
+      def node_referenced?(iid, alcn_list, node_alcn) #:nodoc:
+        alcn_list.flatten.any? {|alcn| alcn == node_alcn}
+      end
+
+      # Use Webgen::NodeFinder to generate a (nested) list of nodes. The options hash has to contain
+      # two keys:
+      #
+      # * :opts → the node finder option set
+      # * :ref_alcn → the alcn of the reference node
+      #
+      def node_finder_option_set(options)
+        @website.ext.node_finder.find(options[:opts], @website.tree[options[:ref_alcn]])
+      end
+
+      # Return the list of nodes.
+      def node_list(method_name, options)
+        if method_name.kind_of?(Array)
+          Webgen::Utils.const_for_name(method_name.first).send(method_name.last, @website, options)
+        else
+          send(method_name, options)
+        end
+      rescue Exception
+        []
+      end
+      private :node_list
+
+      # Map the (nested) list of nodes to a (nested) list of alcn.
+      def nodes_to_alcn(nodes) #:nodoc:
+        nodes.map {|node, children| children.nil? ? node.alcn : [node.alcn, nodes_to_alcn(children)]}
+      end
+      private :nodes_to_alcn
+
+    end
+
+  end
+end

data/lib/webgen/logger.rb

@@ -1,97 +1,41 @@
 # -*- encoding: utf-8 -*-
 
-require 'stringio'
 require 'logger'
 
 module Webgen
 
-  # The class used by a Website to do the logging and the normal output.
-  class Logger
-
-    # Specifies whether log output should be synchronous with normal output.
-    attr_reader :sync
-
-    # Normal output verbosity (:normal, :verbose, :quiet).
-    attr_accessor :verbosity
-
-    # Create a new Logger object which uses +outdev+ as output device. If +sync+ is set to +true+,
-    # log messages are interspersed with normal output.
-    def initialize(outdev=$stdout, sync=false)
-      @sync = sync
-      @outdev = outdev
-      @logger = (@sync ? ::Logger.new(@outdev) : ::Logger.new(@logio = StringIO.new))
-      @logger.formatter = Proc.new do |severity, timestamp, progname, msg|
-        if self.level == ::Logger::DEBUG
-          "%5s -- %s: %s\n" % [severity, progname, msg ]
-        else
-          "%5s -- %s\n" % [severity, msg]
-        end
-      end
-      self.level = ::Logger::WARN
-      self.verbosity = :normal
-      @marks = []
-    end
-
-    # Returns the output of the logger when #sync is +false+. Otherwise an empty string is returned.
-    def log_output
-      if @sync
-        ''
-      else
-        out = @logio.string.dup
-        @marks.reverse.each_with_index do |mark, index|
-          out.insert(mark, " INFO -- Log messages for run #{@marks.length - index} are following\n")
-        end if out.length > 0
-        out
-      end
-    end
-
-    # Only used when #sync is +false: Mark the location in the log stream where a new update/write
-    # run begins.
-    def mark_new_cycle
-      if !@sync
-        @marks << @logio.string.length
-      end
+  # This custom logger class needs to be used (either directly or via a sub-class) for the
+  # Webgen::Website logging object.
+  #
+  # It provides the following, additional functionality over the stdlib Logger class:
+  #
+  # * If a logging message is an Array and #verbose is +false+, only the first item of the array is
+  #   output. If #verbose is +true+, the the items of the array are joined using a line break and
+  #   output.
+  #
+  # * You can add verbose info messages using the #vinfo method.
+  #
+  class Logger < ::Logger
+
+    # Whether verbose log message should be output. Either +true+ or +false+ (default: +false+).
+    attr_accessor :verbose
+
+    def initialize(*args, &block) #:nodoc:
+      super
+      @verbose = false
     end
 
-    # The severity threshold level.
-    def level
-      @logger.level
+    def format_message(severity, datetime, progname, msg) #:nodoc:
+      first, *rest = *msg
+      msg = (@verbose ? [first, *rest].join("\n") : first)
+      super(severity, datetime, progname, msg)
     end
 
-    # Set the severity threshold to +value+ which can be one of the stdlib Logger severity levels.
-    def level=(value)
-      @logger.level = value
+    # Log a verbose info message.
+    def vinfo(progname = nil, &block)
+      add(::Logger::INFO, nil, progname, &block) if @verbose
     end
 
-    # Log a message of +sev_level+ from +source+. The mandatory block has to return the message.
-    def log(sev_level, source='', &block)
-      if sev_level == :stdout
-        @outdev.write(block.call + "\n") if @verbosity == :normal || @verbosity == :verbose
-      elsif sev_level == :verbose
-        @outdev.write(block.call + "\n") if @verbosity == :verbose
-      else
-        @logger.send(sev_level, source, &block)
-      end
-    end
-
-    # Utiltity method for logging an error message.
-    def error(source='', &block); log(:error, source, &block); end
-
-    # Utiltity method for logging a warning message.
-    def warn(source='', &block); log(:warn, source, &block); end
-
-    # Utiltity method for logging an informational message.
-    def info(source='', &block); log(:info, source, &block); end
-
-    # Utiltity method for logging a debug message.
-    def debug(source='', &block); log(:debug, source, &block); end
-
-    # Utiltity method for writing a normal output message.
-    def stdout(source='', &block); log(:stdout, source, &block); end
-
-    # Utiltity method for writing a verbose output message.
-    def verbose(source='', &block); log(:verbose, source, &block); end
-
   end
 
 end

data/lib/webgen/node.rb

@@ -1,27 +1,19 @@
 # -*- encoding: utf-8 -*-
 
-require 'webgen/websiteaccess'
-require 'webgen/loggable'
-require 'webgen/path'
-require 'uri'
-require 'set'
 require 'pathname'
+require 'webgen/languages'
+require 'webgen/path'
 
 module Webgen
 
   # Represents a file, a directory or a fragment. A node always belongs to a Tree.
   #
-  # All needed meta and processing information is associated with a Node. The meta information is
-  # available throught the #[] and #meta_info accessors, the processing information through the
-  # #node_info accessor.
+  # All needed meta and processing information is associated with the node itself. The meta
+  # information is available through the #[] and #meta_info accessors, the internal processing
+  # information through the #node_info accessor.
   #
-  # Although node information should be changed by code, it is not advised to change meta
-  # information values in code since this may lead to unwanted behaviour!
   class Node
 
-    include WebsiteAccess
-    include Loggable
-
     # The parent node. This is in all but one case a Node object. The one exception is that the
     # parent of the Tree#dummy_node is a Tree object.
     attr_reader :parent
@@ -29,21 +21,15 @@ module Webgen
     # The child nodes of this node.
     attr_reader :children
 
-    # The full output path of this node.
-    attr_reader :path
-
-    # The tree to which this node belongs.
-    attr_reader :tree
-
     # The canonical name of this node.
     attr_reader :cn
 
-    # The absolute canonical name of this node.
-    attr_reader :acn
-
     # The localized canonical name of this node.
     attr_reader :lcn
 
+    # The absolute canonical name of this node.
+    attr_reader :acn
+
     # The absolute localized canonical name of this node.
     attr_reader :alcn
 
@@ -53,51 +39,63 @@ module Webgen
     # The language of this node.
     attr_reader :lang
 
-    # Meta information associated with the node.
+    # Meta information associated with the node. If you need just a value for a meta information
+    # key, use the #[] method.
     attr_reader :meta_info
 
+    # Return the node information hash which contains information for processing the node.
+    attr_reader :node_info
+
+    # The full destination path of this node.
+    attr_reader :dest_path
+
+    # The tree to which this node belongs.
+    attr_reader :tree
+
+
     # Create a new Node instance.
     #
     # [+parent+ (immutable)]
     #    The parent node under which this nodes should be created.
-    # [+path+ (immutable)]
-    #    The full output path for this node. If this node is a directory, the path must have a
-    #    trailing slash (<tt>dir/</tt>). If it is a fragment, the hash sign must be the first
-    #    character of the path (<tt>#fragment</tt>). This can also be an absolute path like
-    #    <tt>http://myhost.com/</tt>.
+    #
     # [+cn+ (immutable)]
-    #    The canonical name for this node. Needs to be of the form <tt>basename.ext</tt> or
-    #    <tt>basename</tt> where +basename+ does not contain any dots. Also, the +basename+ must not
-    #    include a language part!
+    #    The canonical name for this node. Needs to be of the form 'basename.ext' or 'basename'
+    #    where +basename+ does not contain any dots. Also, the +basename+ must not include a
+    #    language part!
+    #
+    # [+dest_path+ (immutable)]
+    #    The full output path for this node. If this node is a directory, the path must have a
+    #    trailing slash ('dir/'). If it is a fragment, it has to include a hash sign. This can also
+    #    be an absolute path like http://example.com.
+    #
     # [+meta_info+]
     #    A hash with meta information for the new node.
     #
     # The language of a node is taken from the meta information +lang+ and the entry is deleted from
     # the meta information hash. The language cannot be changed afterwards! If no +lang+ key is
-    # found, the node is language neutral.
-    def initialize(parent, path, cn, meta_info = {})
+    # found, the node is unlocalized.
+    def initialize(parent, cn, dest_path, meta_info = {})
       @parent = parent
-      @cn = cn.freeze
       @children = []
-      reinit(path, meta_info)
-      init_rest
-    end
+      @cn = cn.freeze
+      @dest_path = dest_path.freeze
 
-    # Re-initializes an already initialized node and resets it to its pristine state.
-    def reinit(path, meta_info = {})
-      old_path = @path if defined?(@path)
-      @path = path.freeze
       @lang = Webgen::LanguageManager.language_for_code(meta_info.delete('lang'))
       @lang = nil unless is_file?
+
+      @lcn = Webgen::Path.lcn(@cn, @lang).freeze
+      @acn = (@parent.kind_of?(Webgen::Node) ? @parent.acn.sub(/#.*$/, '') + @cn : '').freeze
+      @alcn = (@parent.kind_of?(Webgen::Node) ? @parent.alcn.sub(/#.*$/, '') + @lcn : '').freeze
+
       @meta_info = meta_info
-      @flags = Set.new([:dirty, :created])
-      if defined?(@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
+      @node_info = {}
+
+      @level = -1
+      @tree = @parent
+      (@level += 1; @tree = @tree.parent) while @tree.kind_of?(Webgen::Node)
+
+      @tree.register_node(self)
+      @parent.children << self unless @parent == @tree
     end
 
     # Return the meta information item for +key+.
@@ -105,390 +103,147 @@ module Webgen
       @meta_info[key]
     end
 
-    # Assign +value+ to the meta information item for +key+.
-    def []=(key, value)
-      @meta_info[key] = value
-    end
-
-    # Return the node information hash which contains information for processing the node.
-    def node_info
-      tree.node_info[@alcn] ||= {}
-    end
-
     # Check if the node is a directory.
-    def is_directory?; @path[-1] == ?/ && !is_fragment?; end
-
-    # Check if the node is a file.
-    def is_file?; !is_directory? && !is_fragment?; end
-
-    # Check if the node is a fragment.
-    def is_fragment?; @cn[0] == ?# end
-
-    # 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)
+    def is_directory?
+      @cn[-1] == ?/ && !is_fragment?
     end
 
-    # Flag the node with the +keys+ and dispatch the message <tt>:node_flagged</tt> with +self+ and
-    # +keys+ as arguments. 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 and dispatch the message <tt>:node_unflagged</tt> with
-    # +self+ and +keys+ as arguments.
-    def unflag(*keys)
-      @flags.subtract(keys)
-      website.blackboard.dispatch_msg(:node_unflagged, self, keys)
+    # Check if the node is a file.
+    def is_file?
+      !is_directory? && !is_fragment?
     end
 
-    # Return +true+ if the node has changed since the last webgen run. If it has changed, +dirty+ is
-    # set to +true+.
-    #
-    # Sends the message <tt>:node_changed?</tt> with +self+ as argument unless the node is already
-    # dirty. A listener to this message should set the flag <tt>:dirty</tt> on the passed node if he
-    # thinks it is dirty.
-    def changed?
-      if_not_checked(:node) do
-        flag(:dirty) if meta_info_changed? || user_nodes_changed? ||
-          node_info[:used_nodes].any? {|n| n != @alcn && (!tree[n] || tree[n].changed?)} ||
-          node_info[:used_meta_info_nodes].any? {|n| n != @alcn && (!tree[n] || tree[n].meta_info_changed?)}
-        website.blackboard.dispatch_msg(:node_changed?, self) unless flagged?(:dirty)
-      end
-      flagged?(:dirty)
+    # Check if the node is a fragment.
+    def is_fragment?
+      @cn[0] == ?#
     end
 
-    # Return +true+ if any node matching a pattern from the meta information +used_nodes+ has changed.
-    def user_nodes_changed?
-      pattern = [@meta_info['used_nodes']].flatten.compact.collect {|pat| Webgen::Path.make_absolute(parent.alcn, pat)}
-      tree.node_access[:alcn].any? do |path, n|
-        pattern.any? {|pat| n =~ pat && n.changed?}
-      end if pattern.length > 0
+    # Check if the node is the root node.
+    def is_root?
+      self == tree.root
     end
-    private :user_nodes_changed?
 
-    # Return +true+ if the meta information of the node has changed.
+    # Check if the this node is an ancestor of +node+.
     #
-    # Sends the message <tt>:node_meta_info_changed?</tt> with +self+ as argument unless the meta
-    # information of the node is already dirty. A listener to this message should set the flag
-    # <tt>:dirt_meta_info</tt> on the passed node if he thinks that the node's meta information is
-    # dirty.
-    def meta_info_changed?
-      if_not_checked(:meta_info) do
-        website.blackboard.dispatch_msg(:node_meta_info_changed?, self) unless flagged?(:dirty_meta_info)
-      end
-      flagged?(:dirty_meta_info)
+    # The check is performed using only the +parent+ information of the involved nodes, NOT the
+    # actual alcn values!
+    def is_ancestor_of?(node)
+      node = node.parent
+      node = node.parent while node != tree.dummy_root && node != self
+      node != tree.dummy_root
     end
 
-    # Return the string representation of the node which is just the alcn.
+    # Return the string representation of the node which is just the #alcn.
     def to_s
       @alcn
     end
 
-    # Return an informative representation of the node.
-    def inspect
+    def inspect #:nodoc:
       "<##{self.class.name}: alcn=#{@alcn}>"
     end
 
-    # Return +true+ if the alcn matches the pattern. See Webgen::Path.match for more information.
+    # Return +true+ if the #alcn matches the pattern.
+    #
+    # See Webgen::Path.matches_pattern? for more information.
     def =~(pattern)
-      Webgen::Path.match(@alcn, pattern)
-    end
-
-    # Sort nodes by using the meta info +sort_info+ (or +title+ if +sort_info+ is not set) of both
-    # involved nodes.
-    def <=>(other)
-      self_so = (@meta_info['sort_info'] && @meta_info['sort_info'].to_s) || @meta_info['title'] || ''
-      other_so = (other['sort_info'] && other['sort_info'].to_s) || other['title'] || ''
-      if self_so !~ /\D/ && other_so !~ /\D/
-        self_so = self_so.to_i
-        other_so = other_so.to_i
-      end
-      self_so <=> other_so
-    end
-
-    # This pattern is the the same as URI::UNSAFE except that the hash character (#) is also
-    # not escaped. This is needed sothat paths with fragments work correctly.
-    URL_UNSAFE_PATTERN = Regexp.new("[^#{URI::PATTERN::UNRESERVED}#{URI::PATTERN::RESERVED}#]") # :nodoc:
-
-    # Construct an internal URL for the given +name+ which can be an acn/alcn/path. If the parameter
-    # +make_absolute+ is +true+, then a relative URL will be made absolute by prepending the special
-    # URL <tt>webgen:://webgen.localhost/</tt>.
-    def self.url(name, make_absolute = true)
-      url = URI::parse(URI::escape(name, URL_UNSAFE_PATTERN))
-      url = URI::parse('webgen://webgen.localhost/') + url unless url.absolute? || !make_absolute
-      url
+      Webgen::Path.matches_pattern?(@alcn, pattern)
     end
 
-
-    # Check if the this node is in the subtree which is spanned by +node+. The check is performed
-    # using only the +parent+ information of the involved nodes, NOT the actual path/alcn values!
-    def in_subtree_of?(node)
-      temp = self
-      temp = temp.parent while temp != tree.dummy_root && temp != node
-      temp != tree.dummy_root
-    end
-
-    # Return the node with the same canonical name but in language +lang+ or, if no such node
-    # exists, an unlocalized version of the node. If no such node is found either, +nil+ is
-    # returned.
-    def in_lang(lang)
-      avail = @tree.node_access[:acn][@acn]
-      avail.find do |n|
-        n = n.parent while n.is_fragment?
-        n.lang == lang
-      end || avail.find do |n|
-        n = n.parent while n.is_fragment?
-        n.lang.nil?
-      end
-    end
-
-    # Return the node representing the given +path+ which can be an acn/alcn. 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 if the path is invalid, +nil+ is returned.
+    # Return the node representing the given +path+ in the given language.
     #
-    # If the +path+ is an alcn and a node is found, it is returned. If the +path+ is an acn, the
-    # correct localized node according to +lang+ is returned or if no such node exists but an
-    # unlocalized version does, the unlocalized node is returned.
-    def resolve(path, lang = nil, use_passive_sources = true)
-      orig_path = path
-      url = self.class.url(@alcn) + self.class.url(path, false)
-
-      path = url.path + (url.fragment.nil? ? '' : '#' + url.fragment)
-      return nil if path =~ /^\/\.\./
-
-      node = @tree[path, :alcn]
-      if !node || node.acn == path
-        (node = (@tree[path, :acn] || @tree[path + '/', :acn])) && (node = node.in_lang(lang))
-      end
-      if !node && use_passive_sources && !website.config['passive_sources'].empty?
-        nodes = website.blackboard.invoke(:create_nodes_from_paths, [path])
-        node = resolve(orig_path, lang, false)
-        node.node_info[:used_meta_info_nodes] += nodes.collect {|n| n.alcn} if node
-      end
-      node
+    # The path can be absolute (i.e. starting with a slash) or relative to the current node.
+    # Relative paths are made absolute by using the #alcn of the current node.
+    #
+    # If the +lang+ parameter is not used, it defaults to the language of the current node.
+    #
+    # See Tree#resolve_node for detailed information on how the correct node for the path is found
+    # and for the +msg_on_failure+ parameter.
+    def resolve(path, lang = @lang, msg_on_failure = false)
+      @tree.resolve_node(Webgen::Path.append(@alcn, path), lang, msg_on_failure)
     end
 
-    # Return the relative path to the given path +other+. The parameter +other+ can be a Node or a
-    # String.
-    def route_to(other)
-      my_url = self.class.url(@path)
-      other_url = if other.kind_of?(Node)
-                    self.class.url(other.routing_node(@lang).path)
-                  elsif other.kind_of?(String)
-                    my_url + other
-                  else
-                    raise ArgumentError, "improper class for argument"
-                  end
+    # Return the relative path to the given node.
+    #
+    # If the +lang+ parameter is not used, it defaults to the language of the current node.
+    def route_to(node, lang = @lang)
+      my_url = Webgen::Path.url(@dest_path)
+      other_url = Webgen::Path.url(node.proxy_node(lang).dest_path)
 
       # 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 == '' ? File.basename(self.path) : route)
+      (route == '' ? File.basename(@dest_path) : route)
     end
 
-    # Return the routing node in language +lang+ which is the node that is used when routing to this
-    # node. The returned node can differ from the node itself in case of a directory where the
-    # routing node is the directory index node. If +show_warning+ is +true+ and this node is a
-    # directory node, then a warning is logged if no associated index file is found.
-    def routing_node(lang, log_warning = true)
-      if !is_directory?
+    # Return the proxy node in language +lang+.
+    #
+    # This node should be used, for example, when routing to this node. The proxy node is found by
+    # using the +proxy_path+ meta information. This meta information is usually set on directories
+    # to specify the node that should be used for the "directory index".
+    #
+    # If the +lang+ parameter is not used, it defaults to the language of the current node.
+    def proxy_node(lang = @lang)
+      proxy_path = self['proxy_path']
+      if proxy_path.nil?
         self
       else
-        key = [alcn, :index_node, lang]
-        vcache = website.cache.volatile
-        return vcache[key] if vcache.has_key?(key)
-
-        index_path = self.meta_info['index_path']
-        if index_path.nil?
-          vcache[key] = self
-        else
-          index_node = resolve(index_path, lang)
-          if index_node
-            vcache[key] = index_node
-            log(:info) { "Directory index path for <#{alcn}> => <#{index_node}>" }
-          elsif log_warning
-            vcache[key] = self
-            log(:warn) { "No directory index path found for directory <#{alcn}>" }
-          end
-        end
-        vcache[key] || self
+        resolve(proxy_path, lang, true) || self
       end
     end
 
-    # Return a HTML link from this node to the +node+ or, if this node and +node+ are the same and
-    # the parameter <tt>website.link_to_current_page</tt> is +false+, a +span+ element with the link
-    # text.
+    # Return a HTML link from this node to the given node.
+    #
+    # If the +lang+ parameter is not used, it defaults to the language of the current node.
     #
     # You can optionally specify additional attributes for the HTML element in the +attr+ Hash.
     # Also, the meta information +link_attrs+ of the given +node+ is used, if available, to set
     # attributes. However, the +attr+ parameter takes precedence over the +link_attrs+ meta
     # information. Be aware that all key-value pairs with Symbol keys are removed before the
-    # attributes are written. Therefore you always need to specify general attributes with Strings!
-    #
-    # If the special value <tt>:link_text</tt> is present in the attributes, it will be used as the
-    # link text; otherwise the title of the +node+ will be used.
+    # attributes are written. Therefore you always need to specify general attributes with strings!
     #
-    # If the special value <tt>:lang</tt> is present in the attributes, it will be used as parameter
-    # to the <tt>node.routing_node</tt> call for getting the linked-to node instead of this node's
-    # +lang+ attribute. *Note*: this is only useful when linking to a directory.
-    def link_to(node, attr = {})
+    # If the special value :link_text is present in the attributes, it will be used as the link
+    # text; otherwise the title of the +node+ will be used.
+    def link_to(node, lang = @lang, attr = {})
       attr = node['link_attrs'].merge(attr) if node['link_attrs'].kind_of?(Hash)
-      rnode = node.routing_node(attr[:lang] || @lang)
+      rnode = node.proxy_node(lang)
       link_text = attr[:link_text] || (rnode != node && rnode['routed_title']) || node['title']
       attr.delete_if {|k,v| k.kind_of?(Symbol)}
 
-      use_link = (rnode != self || website.config['website.link_to_current_page'])
-      attr['href'] = self.route_to(rnode) if use_link
+      attr['href'] = self.route_to(node, lang)
+      attr['hreflang'] = rnode.lang.to_s if rnode.lang
       attrs = attr.collect {|name,value| "#{name.to_s}=\"#{value}\"" }.sort.unshift('').join(' ')
-      (use_link ? "<a#{attrs}>#{link_text}</a>" : "<span#{attrs}>#{link_text}</span>")
+      "<a#{attrs}>#{link_text}</a>"
     end
 
-    def find(opts = {})
-      if opts[:alcn]
-        opts[:alcn] = Path.make_absolute(is_directory? ? alcn : parent.alcn.sub(/#.*$/, ''), opts[:alcn].to_s)
-      end
-      opts[:levels] = 100000 unless opts.has_key?(:levels)
-
-      result = find_nodes(opts, nil, 1)
-      result.flatten! if result && (opts[:limit] || opts[:offset])
-      result.sort!(opts[:sort]) if result
-      result.children = result.children[(opts[:offset].to_s.to_i)..(opts[:limit] ? opts[:offset].to_s.to_i + opts[:limit].to_s.to_i - 1 : -1)]
-      result
+    # Return all versions of this node.
+    def versions
+      tree.node_access[:alcn].select {|alcn, n| n.node_info[:path] == node_info[:path]}.
+        each_with_object({}) {|(k, v), h| h[v['version']] = v}
     end
 
-    def find_nodes(opts, parent, level)
-      result = ProxyNode.new(parent, self)
-
-      children.each do |child|
-        c_result = child.find_nodes(opts, result, level + 1)
-        result.children << c_result unless c_result.nil?
-      end if opts[:levels] && level <= opts[:levels]
-
-      (!result.children.empty? || find_match?(opts) ? result : nil)
-    end
-    protected :find_nodes
-
-    def find_match?(opts)
-      (!opts[:alcn] || self =~ opts[:alcn])
-    end
-    private :find_match?
 
     #######
     private
     #######
 
-    # Do the rest of the initialization.
-    def init_rest
-      @lcn = Path.lcn(@cn, @lang)
-      @acn = (@parent.kind_of?(Tree) ? '' : @parent.acn.sub(/#.*$/, '') + @cn)
-      @alcn = (@parent.kind_of?(Tree) ? '' : @parent.alcn.sub(/#.*$/, '') + @lcn)
-
-      @level = -1
-      @tree = @parent
-      (@level += 1; @tree = @tree.parent) while !@tree.kind_of?(Tree)
-
-      @tree.register_node(self)
-      @parent.children << self unless @parent == @tree
-
-      self.node_info[:used_nodes] = Set.new
-      self.node_info[:used_meta_info_nodes] = Set.new
-    end
-
-    # Only run the code in the block if this node has not already been checked. Different checks are
-    # supported by setting a different +type+ value.
-    def if_not_checked(type)
-      array = (website.cache.volatile[:node_change_checking] ||= {})[type] ||= []
-      if !array.include?(self)
-        array << self
-        yield
-        array.delete(self)
-      end
-    end
-
-    # Delegate 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.
+    # Delegate missing methods to the associated path handler. The current node is placed into the
+    # argument array as the first argument before the method +name+ is invoked on the path handler.
     def method_missing(name, *args, &block)
-      if node_info[:processor]
-        website.cache.instance(node_info[:processor]).send(name, *([self] + args), &block)
+      if node_info[:path_handler]
+        node_info[:path_handler].send(name, *([self] + args), &block)
       else
         super
       end
     end
 
-  end
-
-  # Encapsulates a node. This class is needed when a hierarchy of nodes should be created but the
-  # original hierarchy should not be destroyed.
-  class ProxyNode
-
-    # Array of child proxy nodes.
-    attr_accessor :children
-
-    # The parent proxy node.
-    attr_accessor :parent
-
-    # The encapsulated node.
-    attr_reader :node
-
-    # Create a new proxy node under +parent+ (also has to be a ProxyNode object) for the real node
-    # +node+.
-    def initialize(parent, node)
-      @parent = parent
-      @node = node
-      @children = []
-    end
-
-    # Sort recursively all children of the node using the wrapped nodes. If +value+ is +false+, no
-    # sorting is done at all. If it is +true+, then the default sort mechanism is used (see
-    # Node#<=>). Otherwise +value+ has to be a meta information key on which should be sorted.
-    def sort!(value = true)
-      return self unless value
-
-      if value.kind_of?(String)
-        self.children.sort! do |a,b|
-          aval, bval = a.node[value].to_s, b.node[value].to_s
-          if aval !~ /\D/ && aval !~ /\D/
-            aval = aval.to_i
-            bval = bval.to_i
-          end
-          aval <=> bval
-        end
+    def respond_to_missing?(symbol, include_private) #:nodoc:
+      if node_info[:path_handler]
+        node_info[:path_handler].send(:respond_to?, symbol, include_private)
       else
-        self.children.sort! {|a,b| a.node <=> b.node}
-      end
-      self.children.each {|child| child.sort!(value)}
-      self
-    end
-
-    # Turn the hierarchy of proxy nodes into a flat list.
-    def flatten!
-      result = []
-      while !self.children.empty?
-        result << self.children.shift
-        result.last.parent = self
-        self.children.unshift(*result.last.children)
-        result.last.children = []
+        super
       end
-      self.children = result
-    end
-
-    # Return the hierarchy under this node as nested list of alcn values.
-    def to_list
-      self.children.inject([]) {|temp, n| temp << n.node.alcn; temp += ((t = n.to_list).empty? ? [] : [t]) }
     end
 
   end