gettalong-webgen 0.5.4.20080929

data/lib/webgen/sourcehandler/sitemap.rb

@@ -0,0 +1,60 @@
+require 'webgen/websiteaccess'
+require 'webgen/sourcehandler/base'
+require 'uri'
+require 'time'
+
+module Webgen::SourceHandler
+
+  # Source handler for creating an XML sitemap based on the specification of http://sitemaps.org.
+  #
+  # Uses Webgen::Common::Sitemap to generate the needed sitemap tree and to check if a sitemap has
+  # changed.
+  class Sitemap
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    # Create an XML sitemap from +parent+ and +path+.
+    def create_node(parent, path)
+      page_from_path(path)
+      path.ext = 'xml'
+      raise "Needed information site_url missing for sitemap <#{path}>" if path.meta_info['site_url'].nil?
+      super(parent, path)
+    end
+
+    # Return the rendered feed represented by +node+.
+    def content(node)
+      require 'builder'
+      list = website.blackboard.invoke(:create_sitemap, node, node.lang, options_for_node(node)).to_lcn_list.flatten
+      sitemap = ::Builder::XmlMarkup.new(:indent => 2)
+      sitemap.instruct!(:xml, :version => '1.0', :encoding => 'UTF-8')
+      sitemap.urlset(:xmlns => "http://www.sitemaps.org/schemas/sitemap/0.9") do
+        list.each do |alcn|
+          item = node.tree[alcn]
+          sitemap.url do |url|
+            sitemap.loc(URI.escape(File.join(node['site_url'], item.path)))
+            sitemap.lastmod(item['modified_at'].iso8601)
+            changefreq = item['change_freq'] || node['default_change_freq']
+            sitemap.changefreq(changefreq) if changefreq
+            priority = item['priority'] || node['default_priority']
+            sitemap.priority(priority) if priority
+          end
+        end
+      end
+      sitemap.target!
+    end
+
+    #######
+    private
+    #######
+
+    # Return a hash with the sitemap-creation-options set on the +node+.
+    def options_for_node(node)
+      options = {}
+      node.meta_info.each {|k,v| options[k] = v if k =~ /\./}
+      options
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/template.rb

@@ -0,0 +1,68 @@
+require 'webgen/websiteaccess'
+require 'webgen/loggable'
+require 'webgen/sourcehandler/base'
+
+module Webgen::SourceHandler
+
+  # Source handler for handling template files in Webgen Page Format.
+  class Template
+
+    include Webgen::WebsiteAccess
+    include Webgen::Loggable
+    include Base
+
+    # Create a template node in +parent+ for +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      super(parent, path) do |node|
+        node.node_info[:page] = page
+      end
+    end
+
+    # Return the template chain for +node+.
+    def templates_for_node(node, lang = node.lang)
+      cached_template = (website.cache.volatile[[node.absolute_lcn, :templates]] ||= {})
+      if cached_template[lang]
+        template_node = cached_template[lang]
+      elsif node['template'].kind_of?(String)
+        template_node = node.resolve(node['template'], lang)
+        if template_node.nil?
+          log(:warn) { "Specified template '#{node['template']}' for <#{node.absolute_lcn}> not found, using default template!" }
+          template_node = default_template(node.parent, lang)
+        end
+        cached_template[lang] = template_node
+      elsif node.meta_info.has_key?('template') && node['template'].nil?
+        template_node = cached_template[lang] = nil
+      else
+        log(:info) { "Using default template in language '#{lang}' for <#{node.absolute_lcn}>" }
+        template_node = default_template(node.parent, lang)
+        if template_node == node && !node.parent.is_root?
+          template_node = default_template(node.parent.parent, lang)
+        end
+        cached_template[lang] = template_node
+      end
+
+      if template_node.nil?
+        []
+      else
+        (template_node == node ? [] : templates_for_node(template_node, lang) + [template_node])
+      end
+    end
+
+    # Return the default template for the directory node +dir+. If the template node is not found,
+    # the parent directories are searched.
+    def default_template(dir_node, lang)
+      template_node = dir_node.resolve(website.config['sourcehandler.template.default_template'], lang)
+      if template_node.nil?
+        if dir_node.is_root?
+          log(:warn) { "No default template in root directory found!" }
+        else
+          template_node = default_template(dir_node.parent, lang)
+        end
+      end
+      template_node
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/virtual.rb

@@ -0,0 +1,75 @@
+require 'uri'
+require 'yaml'
+require 'webgen/sourcehandler/base'
+require 'webgen/websiteaccess'
+
+module Webgen::SourceHandler
+
+  # Handles files which contain specifications for "virtual" nodes, ie. nodes that don't have real
+  # source path.
+  #
+  # This can be used, for example, to provide multiple links to the same node.
+  class Virtual
+
+    include Base
+    include Webgen::WebsiteAccess
+
+    # Create all virtual nodes under +parent+ which are specified in +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      nodes = []
+      YAML::load(page.blocks['content'].content).each do |key, value|
+        key = (key =~ /^\// ? key : File.join(parent.absolute_lcn, key))
+        temp_parent = create_directories(parent.tree.root, File.dirname(key), path)
+
+        temp_path = Webgen::Path.new(key)
+        temp_path.meta_info.update(value || {})
+        temp_path.meta_info['modified_at'] = path.meta_info['modified_at']
+        temp_path.meta_info['no_output'] = true
+        output_path = temp_path.meta_info.delete('url') || key
+        output_path = (URI::parse(output_path).absolute? || output_path =~ /^\// ?
+                       output_path : File.join(temp_parent.absolute_lcn, output_path))
+
+        if key =~ /\/$/
+          nodes << create_directory(temp_parent, key, path, temp_path.meta_info)
+        else
+          nodes << super(temp_parent, temp_path, output_path) {|n| n.node_info[:src] = path.path}
+        end
+      end if page.blocks.has_key?('content')
+      nodes.compact
+    end
+
+    #######
+    private
+    #######
+
+    # Create the needed parent directories for a virtual node.
+    def create_directories(parent, dirname, path)
+      dirname.sub(/^\//, '').split('/').each do |dir|
+        parent = create_directory(parent, File.join(parent.absolute_lcn, dir), path)
+      end
+      parent
+    end
+
+    # Create a virtual directory if it does not already exist.
+    def create_directory(parent, dir, path, meta_info = nil)
+      dir_handler = website.cache.instance('Webgen::SourceHandler::Directory')
+      website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
+                                Webgen::Path.new(File.join(dir, '/')),
+                                dir_handler) do |par, temp_path|
+        node = nil
+        if (node = dir_handler.node_exists?(par, temp_path)) && (!meta_info || node.node_info[:src] != path.path)
+          parent, node = node, nil
+        else
+          temp_path.meta_info.update(meta_info) if meta_info
+          parent = node = dir_handler.create_node(par, temp_path)
+          parent.node_info[:src] = path.path
+        end
+        node
+      end
+      parent
+    end
+
+  end
+
+end

data/lib/webgen/tag.rb

@@ -0,0 +1,23 @@
+module Webgen
+
+  # Namespace for all classes that are useable by Webgen::ContentProcessor::Tag.
+  #
+  # Have a look at the documentation for Webgen::Tag::Base for details on how to implement a tag
+  # class.
+  module Tag
+
+    autoload :Base, 'webgen/tag/base'
+    autoload :Relocatable, 'webgen/tag/relocatable'
+    autoload :Metainfo, 'webgen/tag/metainfo'
+    autoload :Menu, 'webgen/tag/menu'
+    autoload :BreadcrumbTrail, 'webgen/tag/breadcrumbtrail'
+    autoload :Langbar, 'webgen/tag/langbar'
+    autoload :IncludeFile, 'webgen/tag/includefile'
+    autoload :ExecuteCommand, 'webgen/tag/executecommand'
+    autoload :Coderay, 'webgen/tag/coderay'
+    autoload :Date, 'webgen/tag/date'
+    autoload :Sitemap, 'webgen/tag/sitemap'
+
+  end
+
+end

data/lib/webgen/tag/base.rb

@@ -0,0 +1,162 @@
+require 'yaml'
+require 'webgen/loggable'
+require 'webgen/websiteaccess'
+
+# This module should be mixed into any class that wants to serve as a webgen tag class. Have a look
+# a the example below to see how a basic tag class looks like.
+#
+# = Tag classes
+#
+# A tag class is a webgen extension that handles specific webgen tags. webgen tags are used to add
+# dynamic content to page and template files and are made for ease of use.
+#
+# A tag class can handle multiple different tags. Just add a (tag name)-(class name) pair to the
+# <tt>contentprocessor.tags.map</tt> configuration entry for each tag name you want to associate
+# with the tag class. The special name <tt>:default</tt> is used for the default tag class which is
+# called if a tag with an unknown tag name is encountered.
+#
+# The only method needed to be written is +call+ which is called by the tags content processor to
+# 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+.
+#
+# = Tag parameters
+#
+# webgen tags allow the specification of parameters in the tag definition. The method
+# +tag_params_list+ returns all configuration entries that can be set this way. And the method
+# +tag_config_base+ is used to resolve partially stated configuration entries. An additional
+# configuration entry option is also used: <tt>:mandatory</tt>. If this key is set to +true+ for a
+# configuration entry, the entry counts as mandatory and needs to be set in the tag definition. If
+# this key is set to +default+, this means that this entry should be the default mandatory parameter
+# (used when only a string is provided in the tag definition). There *should* be only one default
+# mandatory parameter.
+#
+# = Sample Tag Class
+#
+# Following is a simple tag class example which just reverses the body text and adds some
+# information about the context to the result. Note that the class does not reside in the
+# Webgen::Tag namespace and that the configuration entry is therefore also not under the
+# <tt>tag.</tt> namespace.
+#
+#   class Reverser
+#
+#     include Webgen::Tag::Base
+#
+#     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
+#     end
+#
+#   end
+#
+#   WebsiteAccess.website.config.reverser.do_reverse nil, :mandatory => default
+#   WebsiteAccess.website.config['contentprocessor.tags.map']['reverse'] = 'Reverser'
+#
+module Webgen::Tag::Base
+
+  include Webgen::Loggable
+  include Webgen::WebsiteAccess
+
+  # Return a hash with parameter values extracted from the string +tag_config+.
+  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 = {}
+    end
+    create_params_hash(config, ref_node)
+  end
+
+  # Set the current parameter configuration to +params+.
+  def set_params(params)
+    @params = params
+  end
+
+  # Retrieve the parameter value for +name+. The value is taken from the current parameter
+  # configuration if the parameter is specified there or from the website configuration otherwise.
+  def param(name)
+    (@params && @params.has_key?(name) ? @params[name] : website.config[name])
+  end
+
+  # Default implementation for processing a tag. The parameter +tag+ specifies the name of the tag
+  # which should be processed (useful for tag classes which process different tags).
+  #
+  # The parameter +body+ holds the optional body value for the tag.
+  #
+  # The +context+ parameter holds all relevant information for processing. Have a look at the
+  # Webgen::ContentProcessor::Context class to see what is available.
+  #
+  # The method has to return the result of the tag processing and, optionally, a boolean value
+  # specifying if the result should further be processed (ie. webgen tags replaced).
+  #
+  # Needs to be redefined by classes that mixin this module!
+  def call(tag, body, context)
+    raise NotImplementedError
+  end
+
+  #######
+  private
+  #######
+
+  # The base part of the configuration name. This is normally the class name without the Webgen
+  # module downcased and all "::" substituted with "." (e.g. Webgen::Tag::Menu -> tag.menu).
+  def tag_config_base
+    self.class.name.gsub('::', '.').gsub(/^Webgen\./, '').downcase
+  end
+
+  # Return the list of all parameters for the tag class.
+  def tag_params_list
+    regexp = /^#{tag_config_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 = {}
+    config.each do |key, value|
+      if params.include?(key)
+        result[key] = value
+      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}>" }
+      end
+    end
+    result
+  end
+
+  # Return a valid parameter hash by setting +value+ to the default mandatory parameter.
+  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}>"}
+      {}
+    else
+      {param_name => value}
+    end
+  end
+
+end

data/lib/webgen/tag/breadcrumbtrail.rb

@@ -0,0 +1,71 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Generates a breadcrumb trail for the page. This is especially useful when pages are in deep
+  # hierarchies of directories.
+  class BreadcrumbTrail
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
+
+    # 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}
+      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}" }
+      out
+    end
+
+    #######
+    private
+    #######
+
+    # Return the list of nodes that make up the breadcrumb trail of +node+ according to the current
+    # parameters.
+    def breadcrumb_trail_list(node)
+      list = []
+      omit_index_path = if node.meta_info.has_key?('omit_index_path')
+                          node['omit_index_path']
+                        else
+                          param('tag.breadcrumbtrail.omit_index_path')
+                        end
+      omit_index_path = omit_index_path && node.parent.routing_node(node.lang) == node
+
+      node = node.parent if omit_index_path
+
+      until node == node.tree.dummy_root
+        list.unshift(node)
+        node = node.parent
+      end
+      list[param('tag.breadcrumbtrail.start_level')..param('tag.breadcrumbtrail.end_level')].to_a
+    end
+
+    # Check if the breadcrumb trails for +node+ have changed.
+    def node_changed?(node)
+      return if !node.node_info[:tag_breadcrumb_trail]
+
+      node.node_info[:tag_breadcrumb_trail].each do |(params, cn_alcn), cached_list|
+        cn = node.tree[cn_alcn]
+        set_params(params.to_hash)
+        list = breadcrumb_trail_list(cn)
+        set_params({})
+
+        if (list.map {|n| n.absolute_lcn} != cached_list) ||
+            list.any? {|n| (r = n.routing_node(cn.lang)) && r != node && r.meta_info_changed?}
+          node.dirty = true
+          break
+        end
+      end
+    end
+
+  end
+
+end