thewoolleyman-webgen 0.5.8.20090419

data/lib/webgen/cli/create_command.rb

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+
+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,22 @@
+# -*- encoding: utf-8 -*-
+
+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,88 @@
+# -*- encoding: utf-8 -*-
+
+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,72 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/cli'
+require 'facets/kernel/silence'
+
+# nothing to see here
+module Ramaze # :nodoc:
+end
+
+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-2009.02
+      # - fix for Windows when win32console is not installed
+      # - fix for message displayed on shutdown
+      # - fix for warning message
+      $:.unshift File.join(Webgen.data_dir, 'webgui', 'overrides')
+      require 'win32console'
+      $:.shift
+      silence_warnings do
+        begin
+          require 'ramaze'
+        rescue LoadError
+          puts "The Ramaze web framework which is needed for the webgui was not found."
+          puts "You can install it via 'gem install ramaze --version 2009.02'"
+          return
+        end
+      end
+      def Ramaze.shutdown; # :nodoc:
+      end
+
+      Ramaze::acquire(File.join(Webgen.data_dir, 'webgui', 'controller', '*'))
+      Ramaze::Log.loggers = []
+      Ramaze::Global.setup do |g|
+        g.root = File.join(Webgen.data_dir, 'webgui')
+        g.public_root = File.join(Webgen.data_dir, 'webgui', 'public')
+        g.view_root = File.join(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
+        begin
+          require 'launchy'
+          sleep 2
+          puts 'Launching web browser'
+          Launchy.open('http://localhost:7000')
+        rescue LoadError
+          puts "Can't open browser because the launchy library was not found."
+          puts "You can install it via 'gem install launchy'"
+          puts "Please open a browser window and enter 'http://localhost:7000' into the address bar!"
+        end
+      end
+
+      Ramaze.start
+      puts 'webgui finished'
+    end
+
+  end
+
+end

data/lib/webgen/common.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'pathname'
+
+module Webgen
+
+  # Namespace for classes and methods that provide common functionality.
+  module Common
+
+    autoload :Sitemap, 'webgen/common/sitemap'
+
+    # Make the given +path+ absolute by prepending the absolute path +base+ if necessary. Also
+    # resolves all '..'  and '.' references in +path+.
+    def self.absolute_path(path, base)
+      raise(ArgumentError, 'base has to be an absolute path') unless base =~ /\//
+      Pathname.new(path =~ /^\// ? path : File.join(base, path)).cleanpath.to_s
+    end
+
+  end
+
+end

data/lib/webgen/common/sitemap.rb

@@ -0,0 +1,83 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/tag'
+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 = in_sitemap?(n, lang)
+        [(!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
+
+    # Return +true+ if the +child+ of the +node+ is in the sitemap for the language +lang+.
+    def in_sitemap?(child, lang, allow_index_file = false)
+      ((option('common.sitemap.used_kinds').empty? || option('common.sitemap.used_kinds').include?(child['kind']) ||
+        (child.routing_node(lang, false) != child && in_sitemap?(child.routing_node(lang), lang, true))) &&
+       (option('common.sitemap.any_lang') || child.lang.nil? || child.lang == lang) &&
+       (!option('common.sitemap.honor_in_menu') || child['in_menu']) &&
+       (allow_index_file || child.parent == child.tree.root || child.parent.routing_node(lang) != child))
+    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.flag(:dirty)
+          break
+        end
+      end
+    end
+
+  end
+
+end

data/lib/webgen/configuration.rb

@@ -0,0 +1,153 @@
+# -*- encoding: utf-8 -*-
+
+require 'facets/symbol/to_proc'
+
+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. Also see the {webgen
+  # manual}[http://webgen.rubyforge.org/documentation/manual.html#website-configfile] for
+  # information about the configuration helpers.
+  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.map(&:to_s).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