webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/tag/base.rb

@@ -1,170 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-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+, +create_params_hash+, +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. The default method
-# uses the full class name, strips a <tt>Webgen::</tt> part at the beginning away, substitutes
-# <tt>.</tt> for <tt>::</tt> and makes everything lowercase.
-#
-# 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.alcn + " (" + context.content_node['title'] + ")"
-#       result += "Reference node: " + context.ref_node.alcn
-#       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
-
-  # 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
-      raise Webgen::RenderError.new("Could not parse the tag params '#{tag_config}': #{e.message}",
-                                    self.class.name, nil, ref_node)
-    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)
-             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)
-    end
-
-    result
-  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)
-    (defined?(@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::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 isthe class name without the Webgen module
-  # downcased and all "::" substituted with "." (e.g. Webgen::Tag::Menu -> tag.menu). By overriding
-  # this method one can provide a different way of specifying the base part of the configuration
-  # name.
-  def tag_config_base
-    self.class.name.gsub('::', '.').gsub(/^Webgen\./, '').downcase
-  end
-
-  # Return the list of all parameters for the tag class. All configuration options starting with
-  # +tag_config_base+ are used.
-  def tag_params_list
-    regexp = /^#{tag_config_base}/
-    website.config.data.keys.select {|key| key =~ regexp}
-  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}>" }
-      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}>"}
-      {}
-    else
-      {param_name => value}
-    end
-  end
-
-end

data/lib/webgen/tag/breadcrumbtrail.rb

@@ -1,70 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-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.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}>: #{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.alcn} != cached_list) ||
-            list.any? {|n| (r = n.routing_node(cn.lang)) && r != node && r.meta_info_changed?}
-          node.flag(:dirty)
-          break
-        end
-      end
-    end
-
-  end
-
-end

data/lib/webgen/tag/executecommand.rb

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'cgi'
-require 'tempfile'
-require 'rbconfig'
-
-module Webgen::Tag
-
-  # Executes the given command and returns the standard output. All special HTML characters are
-  # escaped.
-  class ExecuteCommand
-
-    include Webgen::Tag::Base
-
-    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 $?.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')]
-    end
-
-  end
-
-end

data/lib/webgen/tag/includefile.rb

@@ -1,42 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'cgi'
-
-module Webgen::Tag
-
-  # Includes a file verbatim and optionally escapes all special HTML characters and processes webgen
-  # tags in it.
-  class IncludeFile
-
-    include Webgen::Tag::Base
-    include Webgen::WebsiteAccess
-
-    def initialize #:nodoc:
-      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
-    end
-
-    # Include the specified file verbatim in the output, optionally escaping special HTML characters
-    # and processing tags in it.
-    def call(tag, body, context)
-      filename = param('tag.includefile.filename')
-      filename = File.join(website.directory, filename) unless filename =~ /^(\/|\w:)/
-      content = File.open(filename, 'rb') {|f| f.read}
-      content = CGI::escapeHTML(content) if param('tag.includefile.escape_html')
-      (context.dest_node.node_info[:tag_includefile_filenames] ||= []) << [filename, File.mtime(filename)]
-
-      [content, param('tag.includefile.process_output')]
-    end
-
-    #######
-    private
-    #######
-
-    def node_changed?(node)
-      if filenames = node.node_info[:tag_includefile_filenames]
-        node.flag(:dirty) if filenames.any? {|f, mtime| File.mtime(f) > mtime}
-      end
-    end
-
-  end
-
-end

data/lib/webgen/tag/metainfo.rb

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'cgi'
-
-module Webgen::Tag
-
-  # Provides easy access to the meta information of a node.
-  class Metainfo
-
-    include Base
-
-    # Return the meta information key specified in +tag+ of the content node.
-    def call(tag, body, context)
-      output = ''
-      if tag == 'lang'
-        output = context.content_node.lang
-      elsif context.content_node[tag]
-        output = context.content_node[tag].to_s
-        output = CGI::escapeHTML(output) if param('tag.metainfo.escape_html')
-      else
-        log(:error) { "No value for meta info key '#{tag}' in <#{context.ref_node}> found in <#{context.content_node}>" }
-      end
-      output
-    end
-
-  end
-
-end

data/lib/webgen/tag/sitemap.rb

@@ -1,41 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::Tag
-
-  # Generates a sitemap. The sitemap contains the hierarchy of all pages on the web site.
-  class Sitemap
-
-    include Base
-    include Webgen::WebsiteAccess
-
-    # Create the sitemap.
-    def call(tag, body, context)
-      tree = website.blackboard.invoke(:create_sitemap, context.dest_node, context.content_node.lang, @params)
-      (tree.children.empty? ? '' : output_sitemap(tree, context))
-    end
-
-    #######
-    private
-    #######
-
-    # The modified tag base to support the easy specification of common.sitemap.* options.
-    def tag_config_base
-      'common.sitemap'
-    end
-
-    # Create the HTML representation of the sitemap nodes in +tree+ in respect to +context+.
-    def output_sitemap(tree, context)
-      out = "<ul>"
-      tree.children.each do |child|
-        sub = (child.children.length > 0 ? output_sitemap(child, context) : '')
-        out << "<li>" + context.dest_node.link_to(child.node, :lang => child.node.lang || context.content_node.lang)
-        out << sub
-        out << "</li>"
-      end
-      out << "</ul>"
-      out
-    end
-
-  end
-
-end

data/lib/webgen/websiteaccess.rb

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen
-
-  # Should be mixed into modules/classes that need access to the current website object.
-  module WebsiteAccess
-
-    # The methods of this module are available on classes that include WebsiteAccess.
-    module ClassMethods
-
-      # See WebsiteAccess.website
-      def website
-        WebsiteAccess.website
-      end
-
-    end
-
-    def self.included(klass) #:nodoc:
-      super
-      klass.extend(ClassMethods)
-    end
-
-    # Return the current website object or +nil+.
-    def website
-      Thread.current[:webgen_website]
-    end
-    module_function :website
-
-  end
-
-end

data/lib/webgen/websitemanager.rb

@@ -1,125 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'ostruct'
-require 'fileutils'
-require 'webgen/website'
-
-module Webgen
-
-  # This class is used for managing webgen websites. It provides access to website bundles defined
-  # as resources and makes it easy to apply them to a webgen website.
-  #
-  # == General information
-  #
-  # Currently, the following actions are supported:
-  #
-  # * creating a website based on a website bundle (#create_website)
-  # * applying a bundle to an existing website (#apply_bundle)
-  #
-  # Bundles are partial webgen websites that contain certain functionality. For example, most of the
-  # bundles shipped with webgen are style bundles that define the basic page layout or how image
-  # galleries should look like. So style bundles are basically used to change the appearance of
-  # parts (or the whole) website. This makes them a powerful tool as this plugin makes it easy to
-  # change to another style bundle later!
-  #
-  # However, not all bundles have to be style bundles. For example, you could as easily create a
-  # bundle for a plugin or for a complete website (e.g. a blog template).
-  #
-  # == website bundle resource naming convention
-  #
-  # The shipped bundles are defined using resources. Each such resource has to be a directory
-  # containing an optional README file in YAML format in which key-value pairs provide additional
-  # information about the bundle (e.g. copyright information, description, ...). All other
-  # files/directories in the directory are copied to the root of the destination webgen website when
-  # the bundle is used.
-  #
-  # This class uses a special naming convention to recognize website bundles:
-  #
-  # * A resource named <tt>webgen-website-bundle-CATEGORY-NAME</tt> is considered to be a bundle in
-  #   the category CATEGORY called NAME (where CATEGORY is optional). There are no fixed categories,
-  #   one can use anything here! The shipped style bundles are located in the 'style' category. You
-  #   need to use the the full name, i.e. CATEGORY-NAME, for accessing a bundle later.
-  #
-  # Website bundle names have to be unique!
-  class WebsiteManager
-
-    # A hash with the available website bundles (mapping name to infos).
-    attr_reader :bundles
-
-    # The used Website object.
-    attr_reader :website
-
-    # Create a new WebsiteManager.
-    #
-    # If +dir+ is a String, then the website manager is created for the website in the directory
-    # +dir+.
-    #
-    # If +dir+ is a Website object, the website manager is created for the website represented by
-    # +dir+. If the website object is initialized if it isn't already.
-    def initialize(dir)
-      if dir.kind_of?(Webgen::Website)
-        @website = dir
-        @website.init if @website.config.nil?
-      else
-        @website = Webgen::Website.new(dir)
-        @website.init
-      end
-      @bundles = {}
-
-      @website.execute_in_env do
-        prefix = "webgen-website-bundle-"
-        @website.config['resources'].select {|name, data| name =~ /^#{prefix}/}.each do |name, data|
-          add_source(Webgen::Source::Resource.new(name), name.sub(prefix, ''))
-        end
-      end
-    end
-
-    # Treat the +source+ as a website bundle and make it available to the WebsiteManager under
-    # +name+.
-    def add_source(source, name)
-      paths = source.paths.dup
-      readme = paths.select {|path| path == '/README' }.first
-      paths.delete(readme) if readme
-      infos = OpenStruct.new(readme.nil? ? {} : YAML::load(readme.io.data))
-      infos.paths = paths
-      @bundles[name] = infos
-    end
-
-    # Create the basic website skeleton (without any bundle applied).
-    def create_website
-      raise "Directory <#{@website.directory}> does already exist!" if File.exists?(@website.directory)
-      @website.execute_in_env do
-        write_paths(Webgen::Source::Resource.new('webgen-website-skeleton').paths) +
-          [FileUtils.mkdir_p(File.join(@website.directory, 'src'))] # fixes Rubygems bug (see RF#28393)
-      end
-    end
-
-    # Apply the given +bundle+ to the website by copying the files.
-    def apply_bundle(bundle)
-      raise ArgumentError.new("Invalid bundle name") if !@bundles.has_key?(bundle)
-      raise "Directory <#{@website.directory}> does not exist!" unless File.exists?(@website.directory)
-      write_paths(@bundles[bundle].paths)
-    end
-
-    #######
-    private
-    #######
-
-    # Write the paths to the website directory.
-    def write_paths(paths)
-      paths.each do |path|
-        output_path = File.join(@website.directory, path.path)
-        if path.path =~ /\/$/
-          FileUtils.mkdir_p(output_path)
-        else
-          FileUtils.mkdir_p(File.dirname(output_path))
-          path.io.stream do |source|
-            File.open(output_path, 'wb') {|f| FileUtils.copy_stream(source, f) }
-          end
-        end
-      end
-    end
-
-  end
-
-end