gettalong-webgen 0.5.4.20080929

data/lib/webgen/tag/sitemap.rb

@@ -0,0 +1,42 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+
+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/tree.rb

@@ -0,0 +1,80 @@
+require 'webgen/websiteaccess'
+require 'webgen/node'
+
+module Webgen
+
+  # Represents a tree of nodes.
+  class Tree
+
+    include WebsiteAccess
+
+    # The dummy root. This is the default node that gets created when the Tree is created sothat the
+    # real root node can be treated like any other node. It has only one child, namely the real root
+    # node of the tree.
+    attr_reader :dummy_root
+
+    # Direct access to the hashes for node resolving. Only use this for reading purposes! If you
+    # just want to get a specific node for an alcn/acn/output path, use #node instead.
+    attr_reader :node_access
+
+    # The hash containing processing information for each node. This is normally not accessed
+    # directly but via the Node#node_info method.
+    attr_reader :node_info
+
+    # Create a new Tree object.
+    def initialize
+      @node_access = {:alcn => {}, :acn => {}, :path => {}}
+      @node_info = {}
+      @dummy_root = Node.new(self, '', '')
+    end
+
+    # The real root node of the tree.
+    def root
+      @dummy_root.children.first
+    end
+
+    # Access a node via a +path+ of a specific +type+. If type is +alcn+ then +path+ has to be an
+    # absolute localized canonical name, if type is +acn+ then +path+ has to be an absolute
+    # canonical name and if type is +path+ then +path+ needs to be an output path.
+    #
+    # Returns the requested Node or +nil+ if such a node does not exist.
+    def node(path, type = :alcn)
+      (type == :acn ? @node_access[type][path] && @node_access[type][path].first : @node_access[type][path])
+    end
+    alias_method :[], :node
+
+    # 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}"
+      else
+        @node_access[:alcn][node.absolute_lcn] = node
+      end
+      (@node_access[:acn][node.absolute_cn] ||= []) << node
+      if @node_access[:path].has_key?(node.path)
+        raise "Can't have two nodes with same output path: #{node.path}" unless node['no_output']
+      else
+        @node_access[:path][node.path] = node
+      end
+    end
+
+    # Delete the node identified by +node_or_alcn+ and all of its children from the
+    # tree. Directories are only deleted if +delete_dir+ is +true+.
+    def delete_node(node_or_alcn, delete_dir = false)
+      n = node_or_alcn.kind_of?(Node) ? node_or_alcn : @node_access[:alcn][node_or_alcn]
+      return if n.nil? || n == @dummy_root || (n.is_directory? && !delete_dir)
+
+      n.children.dup.each {|child| delete_node(child, delete_dir)}
+
+      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[:path].delete(n.path)
+
+      node_info.delete(n.absolute_lcn)
+    end
+
+  end
+
+end

data/lib/webgen/version.rb

@@ -0,0 +1,6 @@
+module Webgen
+
+  # The version of webgen.
+  VERSION = '0.5.4'
+
+end

data/lib/webgen/webgentask.rb

@@ -0,0 +1,148 @@
+# -*- ruby -*-
+#
+#--
+# webgentask.rb:
+#
+#   Define a task library for running webgen
+#
+# Copyright (C) 2007 Jeremy Hinegardner
+#
+# Tasks restructuration by Massimiliano Filacchioni
+# Modifications for 0.5.0 by 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 'rake'
+require 'rake/tasklib'
+
+module Webgen
+
+  ##
+  # Task library to manage a webgen website.
+  #
+  # It is assumed that you have already used the 'webgen' command to create the website directory
+  # for the site.
+  #
+  # === Basics
+  #
+  #   require 'webgen/webgentask'
+  #
+  #   Webgen::WebgenTask.new
+  #
+  # === Attributes
+  #
+  # The attributes available in the new block are:
+  #
+  # * directory         - the root directory of the webgen site
+  #                       (default Dir.pwd)
+  # * config            - the config block for setting additional configuration options
+  # * clobber_outdir    - remove webgens output directory on clobber
+  #                       (default false)
+  #
+  # === Tasks Provided
+  #
+  # The tasks provided are :
+  #
+  # * webgen         - render the webgen website
+  # * clobber_webgen - remove all the files created during generation
+  #
+  # === Integrate webgen in other project
+  #
+  # To integrate webgen tasks in another project you can use rake namespaces.  For example assuming
+  # webgen's site directory is +webgen+ under the main project directory use the following code
+  # fragment in project Rakefile:
+  #
+  #   require 'webgen/webgentask'
+  #
+  #   namespace :dev do
+  #     Webgen::WebgenTask.new do |site|
+  #       site.directory = File.join(Dir.pwd, "webgen")
+  #       site.clobber_outdir = true
+  #       site.config_block = lambda |config|
+  #         config['website.lang'] = 'de'
+  #       end
+  #     end
+  #   end
+  #
+  #   task :clobber => ['dev:clobber_webgen']
+  #
+  # This will create the following tasks:
+  #
+  # * dev:webgen
+  # * dev:clobber_webgen
+  #
+  # and add dev:clobber_webgen to the main clobber task.
+  #
+  class WebgenTask < ::Rake::TaskLib
+
+    # The directory of the webgen website. This would be the directory of your <tt>config.yaml</tt>
+    # file. Or the parent directory of the <tt>src/</tt> directory for webgen.
+    #
+    # The default for this is assumed to be
+    #   Dir.pwd
+    attr_accessor :directory
+
+    # The configuration block that is invoked when the Webgen::Website object is initialized. This
+    # can be used to set configuration parameters and to avoid having a <tt>config.yaml</tt> file
+    # lying around.
+    attr_accessor :config_block
+
+    # During the clobber, should webgen's output directory be clobbered. The default is false.
+    attr_accessor :clobber_outdir
+
+    # Create webgen tasks. You can override the task name with the parameter +name+.
+    def initialize(name = 'webgen')
+      @name           = name
+      @directory      = Dir.pwd
+      @clobber_outdir = false
+      @config_block   = nil
+
+      yield self if block_given?
+
+      define
+    end
+
+    #######
+    private
+    #######
+
+    def define # :nodoc:
+      desc "Render the webgen website"
+      task @name, :verbosity, :log_level do |t, args|
+        require 'webgen/website'
+        website = Webgen::Website.new(@directory, Webgen::Logger.new($stdout), &@config_block)
+        website.logger.verbosity = args[:verbosity].to_s.intern unless args[:verbosity].to_s.empty?
+        website.logger.level = args[:log_level].to_i if args[:log_level]
+        website.render
+      end
+
+      task :clobber => paste('clobber_', @name)
+
+      desc "Remove webgen products"
+      task paste('clobber_', @name) do
+        require 'webgen/website'
+        website = Webgen::Website.new(@directory, Webgen::Logger.new($stdout), &@config_block)
+        website.clean(@clobber_outdir)
+      end
+    end
+
+  end
+
+end
+

data/lib/webgen/website.rb

@@ -0,0 +1,214 @@
+# Standard lib requires
+require 'logger'
+require 'set'
+require 'fileutils'
+
+# Requirements for Website
+require 'webgen/coreext'
+require 'webgen/loggable'
+require 'webgen/logger'
+require 'webgen/configuration'
+require 'webgen/websiteaccess'
+require 'webgen/blackboard'
+require 'webgen/cache'
+require 'webgen/tree'
+
+# Files for autoloading
+require 'webgen/common'
+require 'webgen/source'
+require 'webgen/output'
+require 'webgen/sourcehandler'
+require 'webgen/contentprocessor'
+
+# Load other needed files
+require 'webgen/path'
+require 'webgen/node'
+require 'webgen/page'
+
+
+# The Webgen namespace houses all classes/modules used by webgen.
+module Webgen
+
+  # Returns the data directory for webgen.
+  def self.data_dir
+    unless defined?(@@data_dir)
+      require 'rbconfig'
+      @@data_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'webgen'))
+      @@data_dir = File.expand_path(File.join(Config::CONFIG["datadir"], "webgen")) if !File.exists?(@@data_dir)
+      raise "Could not find webgen data directory! This is a bug, report it please!" unless File.directory?(@@data_dir)
+    end
+    @@data_dir
+  end
+
+
+  # Represents a webgen website and is used to render it.
+  class Website
+
+    # Raised when the configuration file of the website is invalid.
+    class ConfigFileInvalid < RuntimeError; end
+
+    include Loggable
+
+    # The website configuration. Can only be used after #init has been called (which is
+    # automatically done in #render).
+    attr_reader :config
+
+    # The blackboard used for inter-object communication. Can only be used after #init has been
+    # called.
+    attr_reader :blackboard
+
+    # A cache to store information that should be available between runs. Can only be used after
+    # #init has been called.
+    attr_reader :cache
+
+    # The internal data structure used to store information about individual nodes.
+    attr_reader :tree
+
+    # The logger used for logging. If set to +nil+, logging is disabled.
+    attr_accessor :logger
+
+    # The website directory.
+    attr_reader :directory
+
+    # Create a new webgen website for the website in the directory +dir+. You can provide a
+    # block (has to take the configuration object as parameter) for adjusting the configuration
+    # values during the initialization.
+    def initialize(dir, logger=Webgen::Logger.new($stdout, false), &block)
+      @blackboard = nil
+      @cache = nil
+      @config = nil
+      @logger = logger
+      @config_block = block
+      @directory = dir
+    end
+
+    # Define a service +service_name+ provided by the instance of +klass+. The parameter +method+
+    # needs to define the method which should be invoked when the service is invoked. Can only be
+    # used after #init has been called.
+    def autoload_service(service_name, klass, method = service_name)
+      blackboard.add_service(service_name) {|*args| cache.instance(klass).send(method, *args)}
+    end
+
+    # Initialize the configuration, blackboard and cache objects and load the default configuration
+    # as well as website specific extension files. An already existing configuration/blackboard is
+    # deleted!
+    def init
+      execute_in_env do
+        @blackboard = Blackboard.new
+        @config = Configuration.new
+
+        load 'webgen/default_config.rb'
+        Dir.glob(File.join(@directory, 'ext', '**/init.rb')) {|f| load(f)}
+        read_config_file
+
+        @config_block.call(@config) if @config_block
+        restore_tree_and_cache
+      end
+      self
+    end
+
+    # Render the website (after calling #init if the website is not already initialized).
+    def render
+      execute_in_env do
+        init unless @config
+
+        puts "Starting webgen..."
+        shm = SourceHandler::Main.new
+        shm.render(@tree)
+        save_tree_and_cache
+        puts "Finished"
+
+        if @logger && @logger.log_output.length > 0
+          puts "\nLog messages:"
+          puts @logger.log_output
+        end
+      end
+    end
+
+    # Clean the website directory from all generated output files (including the cache file). If
+    # +del_outdir+ is +true+, then the base output directory is also deleted. When a delete
+    # operation fails, the error is silently ignored and the clean operation continues.
+    #
+    # Note: Uses the configured output instance for the operations!
+    def clean(del_outdir = false)
+      init
+      execute_in_env do
+        output = @blackboard.invoke(:output_instance)
+        @tree.node_access[:alcn].each do |name, node|
+          next if node.is_fragment? || node['no_output'] || node.path == '/' || node == @tree.dummy_root
+          output.delete(node.path) rescue nil
+        end
+
+        if @config['website.cache'].first == :file
+          FileUtils.rm(File.join(@directory, @config['website.cache'].last)) rescue nil
+        end
+
+        if del_outdir
+          output.delete('/') rescue nil
+        end
+      end
+    end
+
+    # The provided block is executed within a proper environment sothat any object can access the
+    # Website object.
+    def execute_in_env
+      set_back = Thread.current[:webgen_website].nil?
+      Thread.current[:webgen_website] = self
+      yield
+    ensure
+      Thread.current[:webgen_website] = nil if set_back
+    end
+
+    #######
+    private
+    #######
+
+    # Restore the tree and the cache from +website.cache+ and returns the Tree object.
+    def restore_tree_and_cache
+      @cache = Cache.new
+      @tree = Tree.new
+      data = if config['website.cache'].first == :file
+               cache_file = File.join(@directory, config['website.cache'].last)
+               File.open(cache_file, 'rb') {|f| f.read} if File.exists?(cache_file)
+             else
+               config['website.cache'].last
+             end
+      cache_data, @tree = Marshal.load(data) rescue nil
+      @cache.restore(cache_data) if cache_data
+    end
+
+    # Save the +tree+ and the +cache+ to +website.cache+.
+    def save_tree_and_cache
+      cache_data = [@cache.dump, @tree]
+      if config['website.cache'].first == :file
+        cache_file = File.join(@directory, config['website.cache'].last)
+        File.open(cache_file, 'wb') {|f| Marshal.dump(cache_data, f)}
+      else
+        config['website.cache'][1] = Marshal.dump(cache_data)
+      end
+    end
+
+    # Update the configuration object for the website with infos found in the configuration file.
+    def read_config_file
+      file = File.join(@directory, 'config.yaml')
+      if File.exists?(file)
+        begin
+          config = YAML::load(File.read(file)) || {}
+          raise 'Structure of config file is not valid, has to be a Hash' if !config.kind_of?(Hash)
+          config.each do |key, value|
+            case key
+            when *Webgen::Configuration::Helpers.public_instance_methods(false) then @config.send(key, value)
+            else @config[key] = value
+            end
+          end
+        rescue RuntimeError, ArgumentError => e
+          raise ConfigFileInvalid, "Configuration invalid: " + e.message
+        end
+      elsif File.exists?(File.join(@directory, 'config.yml'))
+        log(:warn) { "No configuration file called config.yaml found (there is a config.yml - spelling error?)" }
+      end
+    end
+
+  end
+
+end