webgen 0.4.7 → 0.5.0

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,82 @@
+require 'facets/ansicode'
+require 'rbconfig'
+
+Console::ANSICode.define_ansicolor_method(:lred, '1;31')
+Console::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 = %x{stty size}.split.collect {|n| n.to_i }.last rescue 72
+
+    # Used for dynamically formatting the text (setting color, bold face, ...).
+    def self.method_missing(id, text = nil)
+      if USE_ANSI_COLORS && Console::ANSICode.respond_to?(id)
+        Console::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/configuration.rb

@@ -0,0 +1,71 @@
+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 #[]=.
+  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
+
+    # 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

data/lib/webgen/contentprocessor.rb

@@ -0,0 +1,89 @@
+module Webgen
+
+  # Namespace for all content processors.
+  #
+  # = Implementing a content processor
+  #
+  # Content processors are used to process the content of files, normally of files in Webgen Page
+  # Format. A content processor only needs to respond to one method called +call+ and must not take
+  # any parameters in the +initialize+ method. This method is invoked with a
+  # Webgen::ContentProcessor::Context object that provides the whole context (especially the content
+  # and the node chain) and the method needs to return this object. During processing a content
+  # processor normally changes the content of the context but it does not need to.
+  #
+  # A self-written content processor does not need to be in the Webgen::ContentProcessor namespace
+  # but all shipped ones do.
+  #
+  # After writing the content processor class, one needs to add it to the
+  # <tt>contentprocessor.map</tt> hash so that it is used by webgen. The key for the entry needs to
+  # be a short name without special characters or spaces and the value is the class name, not as
+  # constant but as a string.
+  #
+  # = Sample Content Processor
+  #
+  # The following sample content processor checks for a meta information +replace_key+ and replaces
+  # strings of the form <tt>replace_key:path/to/node</tt> with a link to the specified node if it is
+  # found.
+  #
+  # Note how the content node, the reference node and the destination node are used sothat the
+  # correct meta information is used, the node is correctly resolved and the correct relative link
+  # is calculated respectively!
+  #
+  #   class SampleProcessor
+  #
+  #     def call(context)
+  #       if !context.content_node['replace_key'].to_s.empty?
+  #         context.content.gsub!(/#{context.content_node['replace_key']}:([\w\/.]+)/ ) do |match|
+  #           link_node = context.ref_node.resolve($1, context.content_node.lang)
+  #           if link_node
+  #             context.dest_node.link_to(link_node)
+  #           else
+  #             match
+  #           end
+  #         end
+  #       end
+  #       context
+  #     rescue Exception => e
+  #       raise "Error while replacing special key: #{e.message}"
+  #     end
+  #
+  #   end
+  #
+  #   WebsiteAccess.website.config['contentprocessor.map']['replacer'] = 'SampleProcessor'
+  #
+  module ContentProcessor
+
+    autoload :Context, 'webgen/contentprocessor/context'
+    autoload :Tags, 'webgen/contentprocessor/tags'
+    autoload :Blocks, 'webgen/contentprocessor/blocks'
+    autoload :Maruku, 'webgen/contentprocessor/maruku'
+    autoload :RedCloth, 'webgen/contentprocessor/redcloth'
+
+    # Return the list of all available content processors.
+    def self.list
+      WebsiteAccess.website.config['contentprocessor.map'].keys
+    end
+
+    # Return the content processor object identified by +name+.
+    def self.for_name(name)
+      klass = WebsiteAccess.website.config['contentprocessor.map'][name]
+      klass.nil? ? nil : WebsiteAccess.website.cache.instance(klass)
+    end
+
+    # Helper class for accessing content processors in a Webgen::ContentProcessor::Context object.
+    class AccessHash
+
+      # Check if a content processor called +name+ exists.
+      def has_key?(name)
+        Webgen::ContentProcessor.list.include?(name)
+      end
+
+      # Return (and proboably initialize) the content processor called +name+.
+      def [](name)
+        Webgen::ContentProcessor.for_name(name)
+      end
+    end
+
+  end
+
+end

data/lib/webgen/contentprocessor/blocks.rb

@@ -0,0 +1,46 @@
+require 'webgen/loggable'
+
+module Webgen::ContentProcessor
+
+  # Replaces special xml tags with the rendered content of a node.
+  class Blocks
+
+    include Webgen::Loggable
+
+    BLOCK_RE = /<webgen:block\s+name=('|")(\w+)\1\s*(?:\schain=('|")([^'"]+)\3\s*)?\s*\/>/
+
+    # Replace that webgen:block xml tags with the rendered content of a node.
+    def call(context)
+      chain = context[:chain]
+      new_chain = (chain.length > 1 ? chain[1..-1] : chain)
+
+      context.content.gsub!(BLOCK_RE) do |match|
+        block_name = $2
+        if $4.nil?
+          used_chain = new_chain
+        else
+          paths = $4.split(';')
+          used_chain = paths.collect do |path|
+            temp_node = context.ref_node.resolve(path.strip, context.dest_node.lang)
+            log(:error) { "Could not resolve <#{path.strip}> in <#{context.ref_node.absolute_lcn}> in '#{match.to_s}'" } if temp_node.nil?
+            temp_node
+          end.compact
+          next match if used_chain.length != paths.length
+          dest_node = context.content_node
+        end
+        block_node = used_chain.first
+
+        if !block_node.node_info[:page].blocks.has_key?(block_name)
+          raise "Node <#{block_node.absolute_lcn}> has no block named '#{block_name}'"
+        end
+
+        context.dest_node.node_info[:used_nodes] << block_node.absolute_lcn
+        tmp_context = block_node.node_info[:page].blocks[block_name].render(context.clone(:chain => used_chain, :dest_node => dest_node))
+        tmp_context.content
+      end
+      context
+    end
+
+  end
+
+end

data/lib/webgen/contentprocessor/context.rb

@@ -0,0 +1,86 @@
+require 'webgen/contentprocessor'
+
+module Webgen::ContentProcessor
+
+  # The context object that is passed to the +call+ method of a content processor.
+  #
+  # The needed context variables are stored in the +options+ hash. You can set any options you like,
+  # however, there are three noteworthy options:
+  #
+  # <tt>:content</tt>:: The content string that should be processed.
+  # <tt>:processors</tt>:: Normally an AccessHash object providing access to all available content processors.
+  # <tt>:chain</tt>:: The chain of nodes that is processed. There are some utiltity methods for getting
+  #                   special nodes of the chain (see #ref_node, #content_node).
+  class Context
+
+    # Processing options
+    attr_accessor :options
+
+    # Create a new Context object. You can use the +options+ hash to set needed options. The
+    # <tt>:content</tt> option is set to an empty string if not specified in +options+ and
+    # <tt>:processors</tt> is set to a new AccessHash if not specified in +options+.
+    def initialize(options = {})
+      @options = {
+        :content => '',
+        :processors => Webgen::ContentProcessor::AccessHash.new
+      }.merge(options)
+    end
+
+    # Create a copy of the current object. You can use the +options+ parameter to override options
+    # of the current Context object in the newly created Context object.
+    def clone(options = {})
+      self.class.new(@options.merge(options))
+    end
+
+    # Return the value of the option +name+.
+    def [](name)
+      @options[name]
+    end
+
+    # Set the option +name+ to the given +value.
+    def []=(name, value)
+      @options[name] = value
+    end
+
+    # Return the <tt>:content</tt> option.
+    def content
+      @options[:content]
+    end
+
+    # Set the <tt>:content</tt> option to the given +value+.
+    def content=(value)
+      @options[:content] = value
+    end
+
+    # Return the node which represents the file into which everything gets rendered. This is
+    # normally the same node as <tt>#content_node</tt> but can differ in special cases. For example,
+    # when rendering the content of node called <tt>my.page</tt> into the output of the node
+    # <tt>this.page</tt>, <tt>this.page</tt> would be the +dest_node+ and <tt>my.page</tt> would be
+    # the +content_node+.
+    #
+    # The +dest_node+ is not included in the chain but can be set via the option
+    # <tt>:dest_node</tt>!
+    #
+    # The returned node should be used as source node for calculating relative paths to other nodes.
+    def dest_node
+      @options[:dest_node] || self.content_node
+    end
+
+    # Return the reference node, ie. the node which provided the original content for this context
+    # object.
+    #
+    # The returned node should be used, for example, for resolving relative paths.
+    def ref_node
+      @options[:chain] && @options[:chain].first
+    end
+
+    # Return the node that is ultimately rendered.
+    #
+    # This node should be used, for example, for retrieving meta information.
+    def content_node
+      @options[:chain] && @options[:chain].last
+    end
+
+  end
+
+end