gettalong-webgen 0.5.4.20080929

data/lib/webgen/cli.rb

@@ -0,0 +1,118 @@
+require 'cmdparse'
+require 'webgen/website'
+require 'webgen/version'
+
+module Webgen
+
+  # Namespace for all classes that act as CLI commands.
+  #
+  # = Implementing a CLI command
+  #
+  # Each CLI command class needs to be put into this module and has to end with +Command+, otherwise
+  # it is not used. A CLI command is an extension that can be invoked from the webgen command and
+  # thus needs to be derived from CmdParse::Command. For detailed information on this class and the
+  # whole cmdparse package have a look at http://cmdparse.rubyforge.org!
+  #
+  # = Sample CLI command
+  #
+  # Here is a sample CLI command extension:
+  #
+  #   require 'webgen/cli'
+  #
+  #   class Webgen::CLI::SampleCommand < CmdParse::Command
+  #
+  #     def initialize
+  #       super('sample', false)
+  #       self.short_desc = "This sample command just outputs its parameters"
+  #       self.description = Utils.format("Uses the global verbosity level and outputs additional " +
+  #         "information when the level is set to verbose!")
+  #       @username = nil
+  #       self.options = CmdParse::OptionParserWrapper.new do |opts|
+  #         opts.separator "Options:"
+  #         opts.on('-u', '--user USER', String,
+  #           'Specify an additional user name to output') {|@username|}
+  #       end
+  #     end
+  #
+  #     def execute(args)
+  #       if args.length == 0
+  #         raise OptionParser::MissingArgument.new('ARG1 [ARG2 ...]')
+  #       else
+  #         puts "Command line arguments:"
+  #         args.each {|arg| puts arg}
+  #         if commandparser.verbosity == :verbose
+  #           puts "Yeah, some additional information is always cool!"
+  #         end
+  #         puts "The entered username: #{@username}" if @username
+  #       end
+  #     end
+  #
+  #   end
+  #
+  # Note the use of Utils.format in the initialize method so that the long text gets wrapped
+  # correctly! The Utils class provides some other useful methods, too!
+  #
+  # For information about which attributes are available on the webgen command parser instance have
+  # a look at Webgen::CLI::CommandParser!
+  module CLI
+
+    autoload :RunCommand, 'webgen/cli/run_command'
+    autoload :CreateCommand, 'webgen/cli/create_command'
+    autoload :WebguiCommand, 'webgen/cli/webgui_command'
+
+    autoload :Utils, 'webgen/cli/utils'
+
+
+    # This is the command parser class used for handling the webgen command line interface. After
+    # creating an instance, the inherited #parse method can be used for parsing the command line
+    # arguments and executing the requested command.
+    class CommandParser < CmdParse::CommandParser
+
+      # The website directory. Default: the current working directory.
+      attr_reader :directory
+
+      # The verbosity level. Default: <tt>:normal</tt>
+      attr_reader :verbosity
+
+      # The log level. Default: <tt>Logger::WARN</tt>
+      attr_reader :log_level
+
+      def initialize # :nodoc:
+        super(true)
+        @directory = Dir.pwd
+        @verbosity = :normal
+        @log_level = ::Logger::WARN
+        @log_filter = nil
+
+        self.program_name = "webgen"
+        self.program_version = Webgen::VERSION
+        self.options = CmdParse::OptionParserWrapper.new do |opts|
+          opts.separator "Global options:"
+          opts.on("--directory DIR", "-d", String, "The website directory (default: the current directory)") {|@directory|}
+          opts.on("--verbose", "-v", "Print more output") { @verbosity = :verbose }
+          opts.on("--quiet", "-q", "No output") { @verbosity = :quiet }
+          opts.on("--log-level LEVEL", "-l", Integer, "The logging level (0..debug, 3..error)") {|@log_level|}
+          opts.on("--log-filter", "-f", Regexp, 'Filter for logging events') {|@log_filter|}
+        end
+        self.add_command(CmdParse::HelpCommand.new)
+        self.add_command(CmdParse::VersionCommand.new)
+        Webgen::CLI.constants.select {|c| c =~ /.+Command$/ }.each do |c|
+          self.add_command(Webgen::CLI.const_get(c).new, (c == 'RunCommand' ? true : false))
+        end
+      end
+
+      # Utility method for sub-commands to create the correct Webgen::Website object.
+      def create_website
+        website = Webgen::Website.new(@directory) do |config|
+          config['logger.mask'] = @log_filter
+        end
+        website.logger.level = @log_level
+        website.logger.verbosity = @verbosity
+        website
+      end
+
+    end
+
+  end
+
+end

data/lib/webgen/cli/create_command.rb

@@ -0,0 +1,64 @@
+require 'webgen/cli'
+require 'webgen/websitemanager'
+
+module Webgen::CLI
+
+  # The CLI command for creating a webgen website.
+  class CreateCommand < CmdParse::Command
+
+    def initialize #:nodoc:
+      super('create', false)
+      self.description = Utils.format("If the verbosity level is set to verbose, the created files are listed.")
+      @template = 'default'
+      @style = 'andreas07'
+
+      self.short_desc = 'Create a basic webgen website with selectable template/style'
+      self.options = CmdParse::OptionParserWrapper.new do |opts|
+        opts.separator "Options:"
+        opts.on('-t', '--template TEMPLATE', String, 'A website template or "none" (default: default)') do |val|
+          @template = (val == 'none' ? nil : val)
+        end
+        opts.on('-s', '--style STYLE', String, 'A website style or "none" (default: andreas07)') do |val|
+          @style = (val == 'none' ? nil : val)
+        end
+        opts.separator ""
+        opts.separator "Arguments:"
+        opts.separator opts.summary_indent + "DIR: the directory in which the website should be created"
+      end
+    end
+
+    def usage # :nodoc:
+      "Usage: #{commandparser.program_name} [global options] create [options] DIR"
+    end
+
+    def show_help # :nodoc:
+      super
+      wm = Webgen::WebsiteManager.new(commandparser.directory)
+
+      puts
+      puts "Available templates and styles:"
+      puts Utils.headline('Templates')
+      wm.templates.sort.each {|name, entry| Utils.hash_output(name, entry.instance_eval { @table }) }
+      puts Utils.headline('Styles')
+      wm.styles.select {|k,v| k =~ /^website-|[^-]+/ }.sort.each {|name, entry| Utils.hash_output(name, entry.instance_eval { @table }) }
+    end
+
+    # Create a webgen website in the directory <tt>args[0]</tt>.
+    def execute(args)
+      if args.length == 0
+        raise OptionParser::MissingArgument.new('DIR')
+      else
+        wm = Webgen::WebsiteManager.new(args[0])
+        paths = wm.create_website
+        paths += wm.apply_template(@template) if @template
+        paths += wm.apply_style(@style) if @style
+        if commandparser.verbosity == :verbose
+          puts "The following files were created in the directory #{args[0]}:"
+          puts paths.sort.collect {|f| "- " + f }.join("\n")
+        end
+      end
+    end
+
+  end
+
+end

data/lib/webgen/cli/run_command.rb

@@ -0,0 +1,20 @@
+require 'webgen/cli'
+
+module Webgen::CLI
+
+  # The CLI command for rendering a webgen website.
+  class RunCommand < CmdParse::Command
+
+    def initialize # :nodoc:
+      super('render', false)
+      self.short_desc = 'Render the webgen website'
+    end
+
+    # Render the website.
+    def execute(args)
+      commandparser.create_website.render
+    end
+
+  end
+
+end

data/lib/webgen/cli/utils.rb

@@ -0,0 +1,86 @@
+require 'facets/ansicode'
+require 'rbconfig'
+
+ANSICode.define_ansicolor_method(:lred, '1;31')
+ANSICode.define_ansicolor_method(:lblue, '1;34')
+
+module Webgen::CLI
+
+  # Provides methods for other CLI classes for formatting text in a consistent manner.
+  class Utils
+
+    USE_ANSI_COLORS = !Config::CONFIG['arch'].include?('mswin32')
+    DEFAULT_WIDTH = if Config::CONFIG['arch'].include?('mswin32')
+                      72
+                    else
+                      ((size = %x{stty size 2>/dev/null}).length > 0 ? size.split.last.to_i : 72) rescue 72
+                    end
+
+    # Used for dynamically formatting the text (setting color, bold face, ...).
+    def self.method_missing(id, text = nil)
+      if USE_ANSI_COLORS && ANSICode.respond_to?(id)
+        ANSICode.send(id, text.to_s)
+      else
+        text.to_s
+      end
+    end
+
+    # Return an array of lines which represents the text in +content+ formatted sothat no line is
+    # longer than +width+ characters. The +indent+ parameter specifies the amount of spaces
+    # prepended to each line. If +first_line_indented+ is +true+, then the first line is indented.
+    def self.format(content, indent = 0, first_line_indented = false, width = DEFAULT_WIDTH)
+      content = (content || '').dup
+      length = width - indent
+
+      paragraphs = content.split(/\n\n/)
+      if (0..1) === paragraphs.length
+        pattern = /^(.{0,#{length}})[ \n]/m
+        lines = []
+        while content.length > length
+          if content =~ pattern
+            str = $1
+            len = $&.length
+          else
+            str = content[0, length]
+            len = length
+          end
+          lines << (lines.empty? && !first_line_indented ? '' : ' '*indent) + str.gsub(/\n/, ' ')
+          content.slice!(0, len)
+        end
+        lines << (lines.empty? && !first_line_indented ? '' : ' '*indent) + content.gsub(/\n/, ' ') unless content.strip.empty?
+        lines
+      else
+        ((format(paragraphs.shift, indent, first_line_indented, width) << '') +
+         paragraphs.collect {|p| format(p, indent, true, width) << '' }).flatten[0..-2]
+      end
+    end
+
+    # Return a headline with the given +text+ and amount of +indent+.
+    def self.headline(text, indent = 2)
+      ' '*indent + "#{bold(text)}"
+    end
+
+    # Return a section header with the given +text+ formatted in the given +color+ and indented
+    # according to +indent+. The whole text is also left justified to the column specified with
+    # +ljustlength+.
+    def self.section(text, ljustlength = 0, indent = 4, color = :green)
+      ' '*indent + "#{send(color, text)}".ljust(ljustlength - indent + send(color).length)
+    end
+
+    # Creates a listing of the key-value pairs of +hash+ under a section called +name+.
+    def self.hash_output(name, hash)
+      ljust = 20
+      puts section('Name', ljust) + "#{lred(name)}"
+
+      hash.sort_by {|k,v| k.to_s }.each do |name, value|
+        next unless value.respond_to?(:to_str)
+        desc = format(value.to_str, ljust)
+        puts section(name.to_s.capitalize, ljust) + desc.shift
+        desc.each {|line| puts line}
+      end
+      puts
+    end
+
+  end
+
+end

data/lib/webgen/cli/webgui_command.rb

@@ -0,0 +1,49 @@
+require 'webgen/cli'
+
+module Webgen::CLI
+
+  # The CLI command for starting the webgen webgui.
+  class WebguiCommand < CmdParse::Command
+
+    def initialize # :nodoc:
+      super('webgui', false)
+      self.short_desc = 'Starts the webgen webgui'
+    end
+
+    # Render the website.
+    def execute(args)
+      # some fixes for ramaze-2008.06
+      # - fix for Windows bug when win32console is not installed
+      # - fix for message displayed on shutdown
+      $:.unshift File.join(Webgen.data_dir, 'webgui', 'overrides')
+      require 'win32console'
+      $:.shift
+      require 'ramaze'
+      Ramaze::Log.loggers = []
+      def Ramaze.shutdown; # :nodoc:
+      end
+
+      acquire Webgen.data_dir/:webgui/:controller/'*'
+      Ramaze::Global.setup do |g|
+        g.root = Webgen.data_dir/:webgui
+        g.public_root = Webgen.data_dir/:webgui/:public
+        g.view_root = Webgen.data_dir/:webgui/:view
+        g.adapter = :webrick
+        g.port = 7000
+      end
+
+      puts 'Starting webgui on http://localhost:7000, press Control-C to stop'
+      Thread.new do
+        sleep 2
+        puts 'Launching web browser'
+        require 'launchy'
+        Launchy.open('http://localhost:7000')
+      end
+
+      Ramaze.start
+      puts 'webgui finished'
+    end
+
+  end
+
+end

data/lib/webgen/common.rb

@@ -0,0 +1,10 @@
+module Webgen
+
+  # Namespace for classes that provide common functionality.
+  module Common
+
+    autoload :Sitemap, 'webgen/common/sitemap'
+
+  end
+
+end

data/lib/webgen/common/sitemap.rb

@@ -0,0 +1,76 @@
+require 'webgen/tag/menu'
+require 'webgen/websiteaccess'
+
+module Webgen::Common
+
+  # This class provides functionality for creating sitemaps and checking if a sitemap has changed.
+  class Sitemap
+
+    include Webgen::WebsiteAccess
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
+
+    # Return the sitemap tree as Webgen::Tag::Menu::MenuNode created for the +node+ in the language
+    # +lang+ using the provided +options+ which can be any configuration option starting with
+    # <tt>common.sitemap</tt>.
+    def create_sitemap(node, lang, options)
+      @options = options
+      tree = recursive_create(nil, node.tree.root, lang).sort!
+      @options = nil
+      (node.node_info[:common_sitemap] ||= {})[[options.to_a.sort, lang]] = tree.to_lcn_list
+      tree
+    end
+
+    #######
+    private
+    #######
+
+    # Recursively create the sitemap.
+    def recursive_create(parent, node, lang, in_sitemap = true)
+      mnode = Webgen::Tag::Menu::MenuNode.new(parent, node)
+      node.children.map do |n|
+        sub_in_sitemap = ((option('common.sitemap.used_kinds').empty? || option('common.sitemap.used_kinds').include?(n['kind'])) &&
+                          (option('common.sitemap.any_lang') || n.lang.nil? || n.lang == lang) &&
+                          (!option('common.sitemap.honor_in_menu') || n['in_menu']) &&
+                          (parent.nil? || node.routing_node(lang) != n))
+        [(!n.children.empty? || sub_in_sitemap ? n : nil), sub_in_sitemap]
+      end.each do |n, sub_in_sitemap|
+        next if n.nil?
+        sub_node = recursive_create(mnode, n, lang, sub_in_sitemap)
+        mnode.children << sub_node unless sub_node.nil?
+      end
+      (mnode.children.empty? && !in_sitemap ? nil : mnode)
+    end
+
+    # Retrieve the configuration option value for +name+. The value is taken from the current
+    # configuration options hash if +name+ is specified there or from the website configuration
+    # otherwise.
+    def option(name)
+      (@options && @options.has_key?(name) ? @options[name] : website.config[name])
+    end
+
+    # Check if the sitemaps for +node+ have changed.
+    def node_changed?(node)
+      return if !node.node_info[:common_sitemap]
+
+      node.node_info[:common_sitemap].each do |(options, lang), cached_tree|
+        @options = options.to_hash
+        tree = recursive_create(nil, node.tree.root, lang).sort!.to_lcn_list
+        @options = nil
+
+        if (tree != cached_tree) ||
+            (tree.flatten.any? do |alcn|
+               (n = node.tree[alcn]) && (r = n.routing_node(lang)) && r.meta_info_changed?
+             end)
+          node.dirty = true
+          break
+        end
+      end
+    end
+
+
+  end
+
+end

data/lib/webgen/configuration.rb

@@ -0,0 +1,147 @@
+module Webgen
+
+  # Stores the configuration for a webgen website.
+  #
+  # Configuration options should be created like this:
+  #
+  #   config.my.new.config 'value', :doc => 'some', :meta => 'info'
+  #
+  # and later accessed or set using the accessor methods #[] and #[]= or a configuration
+  # helper. These helpers are defined in the Helpers module and provide easier access to complex
+  # configuration options.
+  class Configuration
+
+    # Helper class for providing an easy method to define configuration options.
+    class MethodChain
+
+      def initialize(config) #:nodoc:
+        @config = config
+        @name = ''
+      end
+
+      def method_missing(id, *args) #:nodoc:
+        @name += (@name.empty? ? '' : '.') + id.id2name.sub(/(!|=)$/,'')
+        if args.length > 0
+          value = args.shift
+          @config.data[@name] = value unless @config.data.has_key?(@name) # value is set only the first time
+          @config.meta_info[@name] ||= {}
+          @config.meta_info[@name].update(*args) if args.length > 0
+          nil
+        else
+          self
+        end
+      end
+
+    end
+
+    # This module provides methods for setting more complex configuration options. It is mixed into
+    # Webgen::Configuration so that its methods can be used. Detailed information on the use of the
+    # methods can be found in the "User Manual" in the "Configuration File" section.
+    #
+    # All public methods defined in this module are available for direct use in the
+    # configuration file, e.g. the method named +default_meta_info+ can be used like this:
+    #
+    #   default_meta_info:
+    #     Webgen::SourceHandler::Page:
+    #       in_menu : true
+    #       :action : replace
+    #
+    # All methods have to take exactly one argument, a Hash.
+    #
+    # The special key <tt>:action</tt> should be used for specifying how the configuration option
+    # should be set:
+    #
+    #   replace::  Replace the configuration option with the new values.
+    #   modify::   Replace old values with new values and add missing ones (useful for hashes and
+    #              normally the default value)
+    module Helpers
+
+      # Set the default meta information for source handlers.
+      def default_meta_info(args)
+        args.each do |sh_name, mi|
+          raise ArgumentError, 'Invalid argument for configuration helper default_meta_info' unless mi.kind_of?(Hash)
+          action = mi.delete(:action) || 'modify'
+          mi_hash = (self['sourcehandler.default_meta_info'][complete_source_handler_name(sh_name)] ||= {})
+          case action
+          when 'replace' then mi_hash.replace(mi)
+          else mi_hash.update(mi)
+          end
+        end
+      end
+
+
+      # Set the path patterns used by source handlers.
+      def patterns(args)
+        args.each do |sh_name, data|
+          pattern_arr = (self['sourcehandler.patterns'][complete_source_handler_name(sh_name)] ||= [])
+          case data
+          when Array then pattern_arr.replace(data)
+          when Hash
+            (data['del'] || []).each {|pat| pattern_arr.delete(pat)}
+            (data['add'] || []).each {|pat| pattern_arr << pat}
+          else
+            raise ArgumentError, 'Invalid argument for configuration helper patterns'
+          end
+        end
+      end
+
+
+      # Set the default processing pipeline for a source handler.
+      def default_processing_pipeline(args)
+        args.each do |sh_name, pipeline|
+          raise ArgumentError, 'Invalid argument for configuration helper pipeline' unless pipeline.kind_of?(String)
+          mi_hash = (self['sourcehandler.default_meta_info'][complete_source_handler_name(sh_name)] ||= {})
+          ((mi_hash['blocks'] ||= {})['default'] ||= {})['pipeline'] = pipeline
+        end
+      end
+
+
+      # Complete +sh_name+ by checking if a source handler called
+      # <tt>Webgen::SourceHandler::SH_NAME</tt> exists.
+      def complete_source_handler_name(sh_name)
+        (Webgen::SourceHandler.constants.include?(sh_name) ? 'Webgen::SourceHandler::' + sh_name : sh_name)
+      end
+      private :complete_source_handler_name
+
+    end
+
+
+    include Helpers
+
+    # The hash which stores the meta info for the configuration options.
+    attr_reader :meta_info
+
+    # The configuration options hash.
+    attr_reader :data
+
+    # Create a new Configuration object.
+    def initialize
+      @data = {}
+      @meta_info = {}
+    end
+
+    # Return the configuration option +name+.
+    def [](name)
+      if @data.has_key?(name)
+        @data[name]
+      else
+        raise ArgumentError, "No such configuration option: #{name}"
+      end
+    end
+
+    # Set the configuration option +name+ to the provided +value+.
+    def []=(name, value)
+      if @data.has_key?(name)
+        @data[name] = value
+      else
+        raise ArgumentError, "No such configuration option: #{name}"
+      end
+    end
+
+    def method_missing(id, *args) #:nodoc:
+      MethodChain.new(self).method_missing(id, *args)
+    end
+
+  end
+
+end