webgen 0.5.8 → 0.5.9

data/lib/webgen/tag/base.rb

@@ -21,7 +21,7 @@ require 'webgen/websiteaccess'
 # the actual processing. And the +initialize+ method must not take any parameters!
 #
 # Tag classes *can* also choose to not use this module. If they don't use it they have to provide
-# the following methods: +set_params+, +create_tag_params+, +call+.
+# the following methods: +set_params+, +create_tag_params+, +create_params_hash+, +call+.
 #
 # == Tag parameters
 #
@@ -50,8 +50,8 @@ require 'webgen/websiteaccess'
 #
 #     def call(tag, body, context)
 #       result = param('do_reverse') ? body.reverse : body
-#       result += "Node: " + context.content_node.absolute_lcn + " (" + context.content_node['title'] + ")"
-#       result += "Reference node: " + context.ref_node.absolute_lcn
+#       result += "Node: " + context.content_node.alcn + " (" + context.content_node['title'] + ")"
+#       result += "Reference node: " + context.ref_node.alcn
 #       result
 #     end
 #
@@ -65,17 +65,36 @@ module Webgen::Tag::Base
   include Webgen::Loggable
   include Webgen::WebsiteAccess
 
-  # Return a hash with parameter values extracted from the string +tag_config+.
+  # Create a hash with parameter values extracted from the string +tag_config+ and return it.
   def create_tag_params(tag_config, ref_node)
     begin
       config = YAML::load("--- #{tag_config}")
     rescue ArgumentError => e
-      log(:error) { "Could not parse the tag params '#{tag_config}' in <#{ref_node.absolute_lcn}>: #{e.message}" }
-      config = {}
+      raise Webgen::RenderError.new("Could not parse the tag params '#{tag_config}': #{e.message}",
+                                    self.class.name, nil, ref_node.alcn)
     end
     create_params_hash(config, ref_node)
   end
 
+  # Create and return the parameter hash from +config+ which needs to be a Hash, a String or +nil+.
+  def create_params_hash(config, node)
+    params = tag_params_list
+    result = case config
+             when Hash then create_from_hash(config, params, node)
+             when String then create_from_string(config, params, node)
+             when NilClass then {}
+             else
+               raise Webgen::RenderError.new("Invalid parameter type (#{config.class})",
+                                             self.class.name, nil, node.alcn)
+             end
+
+    unless params.all? {|k| !website.config.meta_info[k][:mandatory] || result.has_key?(k)}
+      raise Webgen::RenderError.new("Not all mandatory parameters set", self.class.name, nil, node.alcn)
+    end
+
+    result
+  end
+
   # Set the current parameter configuration to +params+.
   def set_params(params)
     @params = params
@@ -122,25 +141,6 @@ module Webgen::Tag::Base
     website.config.data.keys.select {|key| key =~ regexp}
   end
 
-  # Create the parameter hash from +config+ which needs to be a Hash, a String or +nil+.
-  def create_params_hash(config, node)
-    params = tag_params_list
-    result = case config
-             when Hash then create_from_hash(config, params, node)
-             when String then create_from_string(config, params, node)
-             when NilClass then {}
-             else
-               log(:error) { "Invalid parameter type (#{config.class}) for tag '#{self.class.name}' in <#{node.absolute_lcn}>" }
-               {}
-             end
-
-    unless params.all? {|k| !website.config.meta_info[k][:mandatory] || result.has_key?(k)}
-      log(:error) { "Not all mandatory parameters for tag '#{self.class.name}' in <#{node.absolute_lcn}> set" }
-    end
-
-    result
-  end
-
   # Return a valid parameter hash taking values from +config+ which has to be a Hash.
   def create_from_hash(config, params, node)
     result = {}
@@ -150,7 +150,7 @@ module Webgen::Tag::Base
       elsif params.include?(tag_config_base + '.' + key)
         result[tag_config_base + '.' + key] = value
       else
-        log(:warn) { "Invalid parameter '#{key}' for tag '#{self.class.name}' in <#{node.absolute_lcn}>" }
+        log(:warn) { "Invalid parameter '#{key}' for tag '#{self.class.name}' in <#{node.alcn}>" }
       end
     end
     result
@@ -160,7 +160,7 @@ module Webgen::Tag::Base
   def create_from_string(value, params, node)
     param_name = params.find {|k| website.config.meta_info[k][:mandatory] == 'default'}
     if param_name.nil?
-      log(:error) { "No default mandatory parameter specified for tag '#{self.class.name}' but set in <#{node.absolute_lcn}>"}
+      log(:error) { "No default mandatory parameter specified for tag '#{self.class.name}' but set in <#{node.alcn}>"}
       {}
     else
       {param_name => value}

data/lib/webgen/tag/breadcrumbtrail.rb

@@ -16,10 +16,10 @@ module Webgen::Tag
     # Create the breadcrumb trail.
     def call(tag, body, context)
       out = breadcrumb_trail_list(context.content_node)
-      (context.dest_node.node_info[:tag_breadcrumb_trail] ||= {})[[@params.to_a.sort, context.content_node.absolute_lcn]] = out.map {|n| n.absolute_lcn}
+      (context.dest_node.node_info[:tag_breadcrumb_trail] ||= {})[[@params.to_a.sort, context.content_node.alcn]] = out.map {|n| n.alcn}
       out = out.map {|n| context.dest_node.link_to(n, :lang => context.content_node.lang) }.
         join(param('tag.breadcrumbtrail.separator'))
-      log(:debug) { "Breadcrumb trail for <#{context.content_node.absolute_lcn}>: #{out}" }
+      log(:debug) { "Breadcrumb trail for <#{context.content_node.alcn}>: #{out}" }
       out
     end
 
@@ -57,7 +57,7 @@ module Webgen::Tag
         list = breadcrumb_trail_list(cn)
         set_params({})
 
-        if (list.map {|n| n.absolute_lcn} != cached_list) ||
+        if (list.map {|n| n.alcn} != cached_list) ||
             list.any? {|n| (r = n.routing_node(cn.lang)) && r != node && r.meta_info_changed?}
           node.flag(:dirty)
           break

data/lib/webgen/tag/coderay.rb

@@ -11,19 +11,30 @@ module Webgen::Tag
     # Highlight the body of the block.
     def call(tag, body, context)
       require 'coderay'
-      options = {
-        :css => :style,
-        :wrap => param('tag.coderay.wrap').to_sym,
-        :line_numbers => (param('tag.coderay.line_numbers') ? :inline : nil),
-        :line_number_start => param('tag.coderay.line_number_start'),
-        :tab_width => param('tag.coderay.tab_width'),
-        :bold_every => param('tag.coderay.bold_every')
-      }
+
+      options = {}
+      if param('tag.coderay.css').to_s == 'other'
+        options[:css] = :class
+      elsif param('tag.coderay.css').to_s == 'class'
+        options[:css] = :class
+        default_css_style_node = context.dest_node.resolve('/stylesheets/coderay-default.css')
+        ((context.persistent[:cp_head] ||= {})[:css_file] ||= []) << context.dest_node.route_to(default_css_style_node)
+        context.dest_node.node_info[:used_meta_info_nodes] << default_css_style_node.alcn
+      else
+        options[:css] = :style
+      end
+      options.merge!(:wrap => param('tag.coderay.wrap').to_sym,
+                     :line_numbers => (param('tag.coderay.line_numbers') ? :inline : nil),
+                     :line_number_start => param('tag.coderay.line_number_start'),
+                     :tab_width => param('tag.coderay.tab_width'),
+                     :bold_every => param('tag.coderay.bold_every'))
 
       if param('tag.coderay.process_body')
         body = website.blackboard.invoke(:content_processor, 'tags').call(context.clone(:content => body)).content
       end
       CodeRay.scan(body, param('tag.coderay.lang').to_sym).html(options)
+    rescue LoadError
+      raise Webgen::LoadError.new('coderay', self.class.name, context.dest_node.alcn, 'coderay')
     end
 
   end

data/lib/webgen/tag/executecommand.rb

@@ -12,14 +12,15 @@ module Webgen::Tag
 
     include Webgen::Tag::Base
 
-    BIT_BUCKET = (Config::CONFIG['arch'].include?('mswin32') ?  "nul" : "/dev/null")
+    BIT_BUCKET = (Config::CONFIG['host_os'] =~ /mswin|mingw/ ?  "nul" : "/dev/null")
 
     # Execute the command and return the standard output.
     def call(tag, body, context)
       command = param('tag.executecommand.command')
       output = `#{command} 2> #{BIT_BUCKET}`
-      if ($? >> 8) != 0
-        raise "Command '#{command}' in <#{context.ref_node.absolute_lcn}> has return value != 0: #{output}"
+      if $?.exitstatus != 0
+        raise Webgen::RenderError.new("Command '#{command}' has return value != 0: #{output}",
+                                      self.class.name, context.dest_node, context.ref_node)
       end
       output = CGI::escapeHTML(output) if param('tag.executecommand.escape_html')
       [output, param('tag.executecommand.process_output')]

data/lib/webgen/tag/langbar.rb

@@ -15,7 +15,7 @@ module Webgen::Tag
     # Return a list of all translations of the content page.
     def call(tag, body, context)
       lang_nodes = all_lang_nodes(context.content_node)
-      (context.dest_node.node_info[:tag_langbar_data] ||= {})[context.content_node.absolute_cn] = lang_nodes.map {|n| n.absolute_lcn}
+      (context.dest_node.node_info[:tag_langbar_data] ||= {})[context.content_node.acn] = lang_nodes.map {|n| n.alcn}
       result = lang_nodes.
         reject {|n| (context.content_node.lang == n.lang && !param('tag.langbar.show_own_lang'))}.
         sort {|a, b| a.lang <=> b.lang}.
@@ -31,7 +31,7 @@ module Webgen::Tag
 
     # Return all nodes with the same absolute cn as +node+.
     def all_lang_nodes(node)
-      node.tree.node_access[:acn][node.absolute_cn]
+      node.tree.node_access[:acn][node.acn]
     end
 
     # Check if the langbar tag for +node+ changed.

data/lib/webgen/tag/link.rb

@@ -9,16 +9,17 @@ module Webgen::Tag
 
     # Return a HTML link to the given (A)LCN.
     def call(tag, body, context)
-      if (dest_node = context.ref_node.resolve(param('tag.link.path'), context.dest_node.lang))
-        context.dest_node.node_info[:used_meta_info_nodes] << dest_node.absolute_lcn
+      if (dest_node = context.ref_node.resolve(param('tag.link.path').to_s, context.dest_node.lang))
+        context.dest_node.node_info[:used_meta_info_nodes] << dest_node.alcn
         context.dest_node.link_to(dest_node, param('tag.link.attr').merge(:lang => context.content_node.lang))
       else
-        raise ArgumentError, 'Resolving of path failed'
+        log(:error) { "Could not resolve path '#{param('tag.link.path')}' in <#{context.ref_node.alcn}>" }
+        context.dest_node.flag(:dirty)
+        ''
       end
-    rescue ArgumentError, URI::InvalidURIError => e
-      log(:error) { "Could not link to path '#{param('tag.link.path')}' in <#{context.ref_node.absolute_lcn}>: #{e.message}" }
-      context.dest_node.flag(:dirty)
-      ''
+    rescue URI::InvalidURIError => e
+      raise Webgen::RenderError.new("Error while parsing path '#{param('tag.link.path')}': #{e.message}",
+                                    self.class.name, context.dest_node, context.ref_node)
     end
 
   end

data/lib/webgen/tag/menu.rb

@@ -44,7 +44,7 @@ module Webgen::Tag
 
       # Return the menu tree under the node as nested list of alcn values.
       def to_lcn_list
-        self.children.inject([]) {|temp, n| temp << n.node.absolute_lcn; temp += ((t = n.to_lcn_list).empty? ? [] : [t]) }
+        self.children.inject([]) {|temp, n| temp << n.node.alcn; temp += ((t = n.to_lcn_list).empty? ? [] : [t]) }
       end
 
     end
@@ -57,7 +57,7 @@ module Webgen::Tag
     def call(tag, body, context)
       tree = specific_menu_tree_for(context.content_node)
 
-      (context.dest_node.node_info[:tag_menu_menus] ||= {})[[@params.to_a.sort, context.content_node.absolute_lcn]] = (tree ? tree.to_lcn_list : nil)
+      (context.dest_node.node_info[:tag_menu_menus] ||= {})[[@params.to_a.sort, context.content_node.alcn]] = (tree ? tree.to_lcn_list : nil)
 
       if !tree || tree.children.empty?
         ''

data/lib/webgen/tag/metainfo.rb

@@ -15,7 +15,7 @@ module Webgen::Tag
       elsif context.content_node[tag]
         output = context.content_node[tag].to_s
       else
-        log(:warn) { "No value for meta info key '#{tag}' in <#{context.ref_node.absolute_lcn}> found in <#{context.content_node.absolute_lcn}>" }
+        log(:error) { "No value for meta info key '#{tag}' in <#{context.ref_node.alcn}> found in <#{context.content_node.alcn}>" }
       end
       output
     end

data/lib/webgen/tag/relocatable.rb

@@ -16,24 +16,13 @@ module Webgen::Tag
 
     # Return the relativized path for the path provided in the tag definition.
     def call(tag, body, context)
-      uri_string = param('tag.relocatable.path')
+      path = param('tag.relocatable.path')
       result = ''
-      unless uri_string.nil?
-        begin
-          uri = URI.parse(uri_string)
-          if uri.absolute?
-            result = uri_string
-          else
-            result = resolve_path(uri_string, context)
-          end
-          if result.empty?
-            log(:error) { "Could not resolve path '#{uri_string}' in <#{context.ref_node.absolute_lcn}>" }
-            context.dest_node.flag(:dirty)
-          end
-        rescue URI::InvalidURIError => e
-          log(:error) { "Error while parsing path for tag relocatable in <#{context.ref_node.absolute_lcn}>: #{e.message}" }
-          context.dest_node.flag(:dirty)
-        end
+      begin
+        result = (Webgen::Node.url(path, false).absolute? ? path : resolve_path(path, context))
+      rescue URI::InvalidURIError => e
+        raise Webgen::RenderError.new("Error while parsing path '#{path}': #{e.message}",
+                                      self.class.name, context.dest_node, context.ref_node)
       end
       result
     end
@@ -42,11 +31,18 @@ module Webgen::Tag
     private
     #######
 
-    # Resolve the path +uri+ using the reference node and return the correct relative path from the
+    # Resolve the path +path+ using the reference node and return the correct relative path from the
     # destination node.
-    def resolve_path(uri, context)
-      dest_node = context.ref_node.resolve(uri, context.dest_node.lang)
-      (dest_node ? context.dest_node.route_to(dest_node) : '')
+    def resolve_path(path, context)
+      dest_node = context.ref_node.resolve(path, context.dest_node.lang)
+      if dest_node
+        context.dest_node.node_info[:used_meta_info_nodes] << dest_node.alcn
+        context.dest_node.route_to(dest_node)
+      else
+        log(:error) { "Could not resolve path '#{path}' in <#{context.ref_node.alcn}>" }
+        context.dest_node.flag(:dirty)
+        ''
+      end
     end
 
   end

data/lib/webgen/tag/tikz.rb

@@ -32,16 +32,15 @@ EOF
     # Create a graphic from the commands in the body of the tag.
     def call(tag, body, context)
       path = param('tag.tikz.path')
-      path = Webgen::Common.absolute_path(path, context.ref_node.parent.absolute_lcn)
+      path = Webgen::Path.make_absolute(context.ref_node.parent.alcn, path)
 
       mem_handler = website.cache.instance('Webgen::SourceHandler::Memory')
       src_path = context.ref_node.node_info[:src]
       parent = website.blackboard.invoke(:create_directories, context.ref_node.tree.root, File.dirname(path), src_path)
       params = @params
 
-      node = website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
-                                       Webgen::Path.new(path, src_path), mem_handler) do |node_parent, node_path|
-        mem_handler.create_node(node_parent, node_path, context.ref_node.absolute_lcn) do |pic_node|
+      node = website.blackboard.invoke(:create_nodes, Webgen::Path.new(path, src_path), mem_handler) do |node_path|
+        mem_handler.create_node(node_path, context.ref_node.alcn) do |pic_node|
           set_params(params)
           document = ERB.new(LATEX_TEMPLATE).result(binding)
           pic_path = compile(document, File.extname(path), context)
@@ -74,9 +73,8 @@ EOF
       output = `#{cmd_prefix} pdflatex --shell-escape -interaction=batchmode #{File.basename(file.path)}.tex`
       if $?.exitstatus != 0
         errors = output.scan(/^!(.*\n.*)/).join("\n")
-        log(:error) { "There was an error creating a TikZ picture in <#{context.ref_node.absolute_lcn}>: #{errors}"}
-        context.dest_node.flag(:dirty)
-        nil
+        raise Webgen::RenderError.new("Error while creating a TikZ picture: #{errors}",
+                                      self.class.name, context.dest_node, context.ref_node)
       else
         cmd = cmd_prefix + "pdfcrop #{File.basename(file.path)}.pdf #{File.basename(file.path)}.pdf; "
         return unless run_command(cmd, context)
@@ -106,9 +104,8 @@ EOF
     def run_command(cmd, context)
       output = `#{cmd}`
       if $?.exitstatus != 0
-        log(:error) { "There was an error running a command for a TikZ picture in <#{context.ref_node.absolute_lcn}>: #{output}"}
-        context.dest_node.flag(:dirty)
-        nil
+        raise Webgen::RenderError.new("Error while running a command for a TikZ picture: #{output}",
+                                      self.class.name, context.dest_node, context.ref_node)
       else
         output
       end

data/lib/webgen/tree.rb

@@ -47,12 +47,12 @@ module Webgen
 
     # A utility method called by Node#initialize. This method should not be used directly!
     def register_node(node)
-      if @node_access[:alcn].has_key?(node.absolute_lcn)
-        raise "Can't have two nodes with same absolute lcn: #{node.absolute_lcn}"
+      if @node_access[:alcn].has_key?(node.alcn)
+        raise "Can't have two nodes with same absolute lcn: #{node.alcn}"
       else
-        @node_access[:alcn][node.absolute_lcn] = node
+        @node_access[:alcn][node.alcn] = node
       end
-      (@node_access[:acn][node.absolute_cn] ||= []) << node
+      (@node_access[:acn][node.acn] ||= []) << node
       register_path(node)
     end
 
@@ -78,11 +78,11 @@ module Webgen
 
       website.blackboard.dispatch_msg(:before_node_deleted, n)
       n.parent.children.delete(n)
-      @node_access[:alcn].delete(n.absolute_lcn)
-      @node_access[:acn][n.absolute_cn].delete(n)
+      @node_access[:alcn].delete(n.alcn)
+      @node_access[:acn][n.acn].delete(n)
       @node_access[:path].delete(n.path)
 
-      node_info.delete(n.absolute_lcn)
+      node_info.delete(n.alcn)
     end
 
   end

data/lib/webgen/version.rb

@@ -3,6 +3,6 @@
 module Webgen
 
   # The version of webgen.
-  VERSION = '0.5.8'
+  VERSION = '0.5.9'
 
 end

data/lib/webgen/website.rb

@@ -21,6 +21,7 @@ require 'webgen/websiteaccess'
 require 'webgen/blackboard'
 require 'webgen/cache'
 require 'webgen/tree'
+require 'webgen/error'
 
 # Files for autoloading
 require 'webgen/common'
@@ -35,6 +36,7 @@ require 'webgen/tag'
 require 'webgen/path'
 require 'webgen/node'
 require 'webgen/page'
+require 'webgen/version'
 
 # Load deprecated classes/methods/...
 require 'webgen/deprecated'
@@ -83,6 +85,33 @@ require 'webgen/deprecated'
 #                     an easy way for users to include dynamic content such as automatically
 #                     generated menus.
 #
+#
+# == General information
+#
+# Here are some detail on the internals of webgen that will help you while developing for webgen:
+#
+# * webgen uses a not so complex system for determining whether a node needs to be recreated or
+#   re-rendered. However, for this to work correctly all extensions have to follow some rules:
+#
+#   * It is necessary that all node alcns from which the content is used are put into the
+#     destination node's <tt>node_info[:used_nodes]</tt> set.
+#
+#   * It is necessary that all other node alcns that are used for a node in any way, even if they
+#     are only referenced or the route to their output path used, have to be put into the node's
+#     <tt>node_info[:used_meta_info_nodes]</tt> set.
+#
+# * Any node that is created during the rendering phase, ie. via a content processor, a tag or in
+#   the #content method of a source handler needs to be put into the rendered node's
+#   <tt>node_info[:used_meta_info_nodes]</tt> or <tt>node_info[:used_nodes]</tt> set (see above for
+#   details)! This is especially necessary when using resolved nodes since resolved nodes can be
+#   created by passive sources!
+#
+# * webgen provides various Error classes. However, errors should only be raised if additional runs
+#   won't correct the problem. For example, if a path cannot be resolved, it is possible that in the
+#   next run a node will be created and that the path can be resolved then. This is always the case,
+#   for example, with fragment nodes! In such cases an error message should be written out to the
+#   log to inform the user that there is a potential problem.
+#
 # == Blackboard services
 #
 # The Blackboard class provides an easy communication facility between objects. It implements the
@@ -104,6 +133,7 @@ require 'webgen/deprecated'
 # <tt>:create_sitemap</tt>:: Common::Sitemap#create_sitemap
 # <tt>:create_directories</tt>:: SourceHandler::Directory#create_directories
 # <tt>:create_nodes</tt>:: SourceHandler::Main#create_nodes
+# <tt>:create_nodes_from_paths</tt>:: SourceHandler::Main#create_nodes_from_paths
 # <tt>:source_paths</tt>:: SourceHandler::Main#find_all_source_paths
 #
 # Following is the list of all messages that can be listened to:
@@ -242,11 +272,11 @@ module Webgen
     def render
       result = nil
       execute_in_env do
-        init unless @config
+        init
 
         puts "Starting webgen..."
         shm = SourceHandler::Main.new
-        result = shm.render(@tree)
+        result = shm.render
         save_tree_and_cache if result
         puts "Finished"