webgen 0.4.7 → 0.5.0

data/lib/webgen/loggable.rb

@@ -0,0 +1,23 @@
+require 'webgen/websiteaccess'
+
+module Webgen
+
+  # This module should be included in all classes that need a logging facility.
+  module Loggable
+
+    # Log the result of the +block+ using the log level +log_level+.
+    def log(sev_level, &block)
+      source = (self.kind_of?(Class) ? self.name : self.class.name) + '#' + caller[0][%r"`.*"][1..-2]
+      if WebsiteAccess.website && WebsiteAccess.website.logger && (!WebsiteAccess.website.config['logger.mask'] || source =~ WebsiteAccess.website.config['logger.mask'])
+        WebsiteAccess.website.logger.send(sev_level, source, &block)
+      end
+    end
+
+    # Shortcut for writing a line to the normal log output.
+    def puts(*args)
+      (args.last == :verbose ? log(:verbose) { args[0..-2].join } : log(:stdout) { args.join })
+    end
+
+  end
+
+end

data/lib/webgen/logger.rb

@@ -0,0 +1,78 @@
+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
+    end
+
+    # Returns the output of the logger when #sync is +false+. Otherwise an empty string is returned.
+    def log_output
+      @sync ? '' : @logio.string
+    end
+
+    # The severity threshold level.
+    def level
+      @logger.level
+    end
+
+    # Set the severity threshold to +value+ which can be one of the stdlib Logger severity levels.
+    def level=(value)
+      @logger.level = value
+    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,273 +1,311 @@
-#
-#--
-#
-# $Id: node.rb 585 2007-01-10 15:48:08Z 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/websiteaccess'
+require 'webgen/loggable'
+require 'webgen/path'
 require 'uri'
+require 'set'
 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
-
-  # The parent node.
-  attr_reader :parent
-
-  # 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
+module Webgen
+
+  # Represents a file, a directory or a fragment. A node always belongs to a Tree.
+  class Node
+
+    include WebsiteAccess
+    include Loggable
+
+    # The parent node.
+    attr_reader :parent
+
+    # The children 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 :absolute_cn
+
+    # The localized canonical name of this node.
+    attr_reader :lcn
+
+    # The absolute localized canonical name of this node.
+    attr_reader :absolute_lcn
+
+    # The level of the node. The level specifies how deep the node is in the hierarchy.
+    attr_reader :level
+
+    # The language of this node.
+    attr_reader :lang
+
+    # 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
+
+    # Has the node been created or has it been read from the cache?
+    attr_accessor :created
+
+    # 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!
+    # +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 = {})
+      @parent = parent
+      @path = path.freeze
+      @cn = cn.chomp('/').freeze
+      @lang = meta_info.delete('lang').freeze
+      @lang = nil unless is_file?
+      @meta_info = meta_info
+      @children = []
+      @dirty = true
+      @created = true
+      init_rest
+    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
+    # Return the meta information item for +key+.
+    def [](key)
+      @meta_info[key]
+    end
 
-  # Sets the path for the node.
-  def path=( path )
-    @path = path
-    precalc!
-  end
+    # Assign +value+ to the meta information item for +key+.
+    def []=(key, value)
+      @meta_info[key] = value
+    end
 
-  # Gets object +name+ from +meta_info+.
-  def []( name )
-    @meta_info[name]
-  end
+    # Return the node information hash which contains information for processing the node.
+    def node_info
+      tree.node_info[@absolute_lcn] ||= {}
+    end
 
-  # Assigns +value+ to +meta_info+ called +name.
-  def []=( name, value )
-    @meta_info[name] = value
-  end
+    # Check if the node is a directory.
+    def is_directory?; @path[-1] == ?/; end
 
-  # Regexp for matching absolute URLs, ie. URLs with a scheme part (also see RFC1738)
-  ABSOLUTE_URL = /^\w[a-zA-Z0-9+.-]*:/
+    # Check if the node is a file.
+    def is_file?; !is_directory? && !is_fragment?; end
 
-  # Returns the full path for this node. See also Node#absolute_path !
-  def full_path
-    return @precalc[:full_path] if @precalc
+    # Check if the node is a fragment.
+    def is_fragment?; @cn[0] == ?# end
 
-    if @path =~ ABSOLUTE_URL
-      @path
-    else
-      (@parent.nil? ? @path : @parent.full_path + @path)
-    end
-  end
+    # Check if the node is the root node.
+    def is_root?; self == tree.root;  end
 
-  # 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 @parent.nil?
-      '/'
-    elsif @path =~ ABSOLUTE_URL
-      @path
-    else
-      full_path.sub( /^#{Regexp.escape(Node.root( self ).path)}/, '/' )
+    # Return +true+ if the node has changed since the last webgen run. If it has changed, +dirty+ is
+    # set to +true+.
+    def 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
+      @dirty
     end
-  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
-
-  # Checks if the node is a directory.
-  def is_directory?
-    @path[-1] == ?/
-  end
-
-  # Checks if the node is a file.
-  def is_file?
-    !is_directory? && !is_fragment?
-  end
-
-  # Checks if the node is a fragment.
-  def is_fragment?
-    @path[0] == ?#
-  end
+    # Return an informative representation of the node.
+    def inspect
+      "<##{self.class.name}: alcn=#{@absolute_lcn}>"
+    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?
-           /^#{Regexp.escape(@path.chomp('/'))}(\/|$)/ =~ path                  #' #emacs hack
-         elsif is_fragment?
-           /^#{Regexp.escape(@path)}$/ =~ path
-         else
-           /^#{Regexp.escape(@path)}(?=#|$)/ =~ path
-         end
-    if md then $& end
-  end
+    # Return +true+ if the alcn matches the pattern. See File.fnmatch for useable patterns.
+    def =~(pattern)
+      File.fnmatch(pattern, @absolute_lcn, File::FNM_DOTMATCH|File::FNM_CASEFOLD|File::FNM_PATHNAME)
+    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
+    # 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 = (self['sort_info'] && self['sort_info'].to_s) || self['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
 
-  # 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
+    # Construct the absolute (localized) canonical name by using the +parent+ node and +name+ (which
+    # can be a cn or an lcn). The +type+ can be either +:alcn+ or +:acn+.
+    def self.absolute_name(parent, name, type)
+      if parent.kind_of?(Tree)
+        ''
+      else
+        parent = parent.parent while parent.is_fragment? # Handle fragment nodes specially in case they are nested
+        parent_name = (type == :alcn ? parent.absolute_lcn : parent.absolute_cn)
+        parent_name + (parent_name !~ /\/$/ && (parent.is_directory? || parent == parent.tree.dummy_root) ? '/' : '') + name
+      end
+    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
+    # Construct an internal URL for the given +name+ which can be a acn/alcn/path.
+    def self.url(name)
+      url = URI::parse(name)
+      url = URI::parse('webgen://webgen.localhost/') + url unless url.absolute?
+      url
     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 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 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
+    # 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
 
-    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://...)
+    # 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][@absolute_cn]
+      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
 
-    node = Node.root( self )
+    # 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.
+    #
+    # 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)
+      url = self.class.url(self.is_directory? ? File.join(@absolute_lcn, '/') : @absolute_lcn) + path
+
+      path = url.path + (url.fragment.nil? ? '' : '#' + url.fragment)
+      path.chomp!('/') unless path == '/'
+      return nil if path =~ /^\/\.\./
+
+      node = @tree[path, :alcn]
+      if node && node.absolute_cn != path
+        node
+      else
+        (node = @tree[path, :acn]) && node.in_lang(lang)
+      end
+    end
 
-    match = nil
-    while !node.nil? && !path.empty?
-      node = node.find {|c| match = (c =~ path) }
-      path.sub!( match, '' ) unless node.nil?
-      break if path.empty?
+    # 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
+
+      # 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)
     end
 
-    node
-  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.
+    def routing_node(lang)
+      if !is_directory?
+        self
+      else
+        key = [absolute_lcn, :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 <#{absolute_lcn}> => <#{index_node.absolute_lcn}>" }
+          else
+            vcache[key] = self
+            log(:warn) { "No directory index path found for directory <#{absolute_lcn}>" }
+          end
+        end
+        vcache[key]
+      end
+    end
 
-  # 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
+    # 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.
+    #
+    # 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. 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. 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!
+    def link_to(node, attr = {})
+      attr = node['link_attrs'].merge(attr) if node['link_attrs'].kind_of?(Hash)
+      link_text = attr[:link_text] || node.routing_node(@lang)['routed_title'] || node['title']
+      attr.delete_if {|k,v| k.kind_of?(Symbol)}
+
+      use_link = (node != self || website.config['website.link_to_current_page'])
+      attr['href'] = self.route_to(node) if use_link
+      attrs = attr.collect {|name,value| "#{name.to_s}=\"#{value}\"" }.sort.unshift('').join(' ')
+      (use_link ? "<a#{attrs}>#{link_text}</a>" : "<span#{attrs}>#{link_text}</span>")
+    end
 
-    url = URI::parse( absolute_path )
-    url = URI::parse( 'webgen://webgen.localhost/' ) + url unless url.absolute?
-    url
-  end
+    #######
+    private
+    #######
 
-  # Returns an informative representation of the node.
-  def inspect
-    "<##{self.class.name}: path=#{full_path}>"
-  end
+    # Do the rest of the initialization.
+    def init_rest
+      @lcn = Path.lcn(@cn, @lang)
+      @absolute_cn = self.class.absolute_name(@parent, @cn, :acn)
+      @absolute_lcn = self.class.absolute_name(@parent, @lcn, :alcn)
 
-  alias_method :to_s, :full_path
+      @level = -1
+      @tree = @parent
+      (@level += 1; @tree = @tree.parent) while !@tree.kind_of?(Tree)
 
-  #######
-  private
-  #######
+      @tree.register_node(self)
+      @parent.children << self unless @parent == @tree
 
-  def precalc!
-    @precalc = nil
-    @precalc = {
-      :full_path => full_path,
-      :absolute_path => absolute_path,
-      :to_url => to_url
-    }
-  end
+      self.node_info[:used_nodes] = Set.new
+    end
 
-  def precalc_with_children!
-    precalc!
-    each {|child| child.precalc_with_children!}
-  end
-  protected :precalc_with_children!
-
-  # 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
+    # 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.
+    def method_missing(name, *args, &block)
+      if node_info[:processor]
+        website.cache.instance(node_info[:processor]).send(name, *([self] + args), &block)
+      else
+        super
+      end
     end
-  end
 
-=begin
-TODO:
-- stable sort which does not switch items that have the same order_info
-=end
+  end
 
 end