gettalong-webgen 0.5.4.20080929

data/lib/webgen/tag/coderay.rb

@@ -0,0 +1,32 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Provides syntax highlighting via the +coderay+ library.
+  class Coderay
+
+    include Webgen::Tag::Base
+    include Webgen::WebsiteAccess
+
+    # Highlight the body of the block.
+    def call(tag, body, context)
+      require 'coderay'
+      options = {
+        :css => :style,
+        :wrap => param('tag.coderay.wrap').to_sym,
+        :line_numbers => (param('tag.coderay.line_numbers') ? :inline : nil),
+        :line_number_start => param('tag.coderay.line_number_start'),
+        :tab_width => param('tag.coderay.tab_width'),
+        :bold_every => param('tag.coderay.bold_every')
+      }
+
+      if param('tag.coderay.process_body')
+        body = website.blackboard.invoke(:content_processor, 'tags').call(context.clone(:content => body)).content
+      end
+      CodeRay.scan(body, param('tag.coderay.lang').to_sym).html(options)
+    end
+
+  end
+
+end

data/lib/webgen/tag/date.rb

@@ -0,0 +1,18 @@
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Prints out the date using a format string which will be passed to Time#strftime. Therefore you
+  # can use everything Time#strftime offers.
+  class Date
+
+    include Base
+
+    # Return the current date formatted as specified.
+    def call(tag, body, context)
+      Time.now.strftime(param('tag.date.format'))
+    end
+
+  end
+
+end

data/lib/webgen/tag/executecommand.rb

@@ -0,0 +1,29 @@
+require 'webgen/tag'
+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['arch'].include?('mswin32') ?  "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 ($? >> 8) != 0
+        raise "Command '#{command}' in <#{context.ref_node.absolute_lcn}> has return value != 0: #{output}"
+      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

@@ -0,0 +1,42 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+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.dirty = true if filenames.any? {|f, mtime| File.mtime(f) > mtime}
+      end
+    end
+
+  end
+
+end

data/lib/webgen/tag/langbar.rb

@@ -0,0 +1,52 @@
+require 'webgen/tag'
+require 'webgen/websiteaccess'
+
+module Webgen::Tag
+
+  # Generates a list with all the languages of the page.
+  class Langbar
+
+    include Webgen::Tag::Base
+    include Webgen::WebsiteAccess
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
+
+    # Return a list of all translations of the content page.
+    def call(tag, body, context)
+      lang_nodes = all_lang_nodes(context.content_node)
+      (context.dest_node.node_info[:tag_langbar_data] ||= {})[context.content_node.absolute_cn] = lang_nodes.map {|n| n.absolute_lcn}
+      result = lang_nodes.
+        reject {|n| (context.content_node.lang == n.lang && !param('tag.langbar.show_own_lang'))}.
+        sort {|a, b| a.lang <=> b.lang}.
+        collect {|n| context.dest_node.link_to(n, :link_text => n.lang, :lang => n.lang)}.
+        join(param('tag.langbar.separator'))
+      (param('tag.langbar.show_single_lang') || lang_nodes.length > 1 ? result : "")
+    end
+
+    #######
+    private
+    #######
+
+    # Return all nodes with the same absolute cn as +node+.
+    def all_lang_nodes(node)
+      node.tree.node_access[:acn][node.absolute_cn]
+    end
+
+    # Check if the langbar tag for +node+ changed.
+    def node_changed?(node)
+      return unless (cdata = node.node_info[:tag_langbar_data])
+      cdata.each do |acn, clang_nodes|
+        lang_nodes = all_lang_nodes(node.tree[acn, :acn]) rescue nil
+        if !lang_nodes || lang_nodes.length != clang_nodes.length ||
+            lang_nodes.any? {|n| n.meta_info_changed?}
+          node.dirty = true
+          break
+        end
+      end
+    end
+
+  end
+
+end

data/lib/webgen/tag/menu.rb

@@ -0,0 +1,186 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Generates a menu that can be configured extensively.
+  class Menu
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    # Special menu node class. It encapsulates the original node for later access.
+    class MenuNode
+
+      # Array of the child nodes.
+      attr_reader :children
+
+      # The parent node.
+      attr_reader :parent
+
+      # The encapsulated node.
+      attr_reader :node
+
+      # Set to +true+ if the menu node is in the tree of files.
+      attr_writer :is_in_tree_of_files
+
+      # Create a new menu node under +parent+ for the real node +node+.
+      def initialize(parent, node)
+        @parent = parent
+        @node = node
+        @children = []
+      end
+
+      # Return +true+ if the menu node is in the menu tree of only files.
+      def is_in_tree_of_files?
+        @is_in_tree_of_files
+      end
+
+      # Sort recursively all children of the node using the wrapped nodes.
+      def sort!
+        self.children.sort! {|a,b| a.node <=> b.node}
+        self.children.each {|child| child.sort!}
+        self
+      end
+
+      # Return the menu tree under the node as nested list of alcn values.
+      def to_lcn_list
+        self.children.inject([]) {|temp, n| temp << n.node.absolute_lcn; temp += ((t = n.to_lcn_list).empty? ? [] : [t]) }
+      end
+
+    end
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
+
+    # Generate the menu.
+    def call(tag, body, context)
+      tree = specific_menu_tree_for(context.content_node)
+
+      (context.dest_node.node_info[:tag_menu_menus] ||= {})[[@params.to_a.sort, context.content_node.absolute_lcn]] = (tree ? tree.to_lcn_list : nil)
+      (tree && !tree.children.empty? ? create_output(context, tree) : '')
+    end
+
+    #########
+    protected
+    #########
+
+    # Check if the menus for +node+ have changed.
+    def node_changed?(node)
+      return if !node.node_info[:tag_menu_menus]
+
+      node.node_info[:tag_menu_menus].each do |(params, cn_alcn), cached_tree|
+        cn = node.tree[cn_alcn]
+        menu_tree = menu_tree_for_lang(cn.lang, cn.tree.root)
+
+        set_params(params.to_hash)
+        tree = build_specific_menu_tree(cn, menu_tree)
+        tree_list = tree.to_lcn_list if tree
+        set_params({})
+
+        if (tree.nil? && !cached_tree.nil?) || (tree_list && tree_list != cached_tree) ||
+            (tree_list && tree_list.flatten.any? do |alcn|
+               (n = node.tree[alcn]) && (r = n.routing_node(cn.lang)) && r != node && r.meta_info_changed?
+             end)
+          node.dirty = true
+          break
+        end
+      end
+    end
+
+    # Wrapper method for returning the specific menu tree for +content_node+.
+    def specific_menu_tree_for(content_node)
+      tree = menu_tree_for_lang(content_node.lang, content_node.tree.root)
+      if param('tag.menu.used_nodes') == 'fragments'
+        @params['tag.menu.start_level'] = param('tag.menu.start_level') + content_node.level
+      end
+      build_specific_menu_tree(content_node, tree)
+    end
+
+    # Build a menu tree for +content_node+ from the tree +menu_node+.
+    def build_specific_menu_tree(content_node, menu_node, level = 1)
+      if menu_node.nil? \
+        || level > param('tag.menu.max_levels') + param('tag.menu.start_level') - 1 \
+        || ((level > param('tag.menu.min_levels') + param('tag.menu.start_level') - 1) \
+             && (menu_node.node.level >= content_node.level \
+                  || (param('tag.menu.show_current_subtree_only') && !content_node.in_subtree_of?(menu_node.node))
+                 )
+            ) \
+        || (level == param('tag.menu.start_level') && !content_node.in_subtree_of?(menu_node.node))
+        return nil
+      end
+
+      sub_menu_tree = MenuNode.new(nil, menu_node.node)
+      menu_tree = MenuNode.new(nil, menu_node.node)
+      menu_node.children.each do |child|
+        next if param('tag.menu.used_nodes') == 'files' && !child.is_in_tree_of_files?
+        menu_tree.children << (this_node = MenuNode.new(menu_tree, child.node))
+        sub_node = child.children.length > 0 ? build_specific_menu_tree(content_node, child, level + 1) : nil
+        sub_node.children.each {|n| this_node.children << n; sub_menu_tree.children << n} if sub_node
+      end
+
+      if level < param('tag.menu.start_level')
+        sub_menu_tree
+      else
+        menu_tree
+      end
+    end
+
+    # Create the HTML menu of the +tree+ using the provided +context+.
+    def create_output(context, tree, level = 1)
+      out = "<ul>"
+      tree.children.each do |child|
+        menu = child.children.length > 0 ? create_output(context, child, level + 1) : ''
+        style, link = menu_item_details(context.dest_node, child.node, context.content_node.lang, level)
+
+        out << "<li #{style}>#{link}"
+        out << menu
+        out << "</li>"
+      end
+      out << "</ul>"
+      out
+    end
+
+    # Return style information (node is selected, ...) and a link from +dest_node+ to +node+.
+    def menu_item_details(dest_node, node, lang, level)
+      styles = ['webgen-menu-level' + level.to_s]
+      styles << 'webgen-menu-submenu' if node.is_directory? || (node.is_fragment? && node.children.length > 0)
+      styles << 'webgen-menu-submenu-inhierarchy' if (node.is_directory? || (node.is_fragment? && node.children.length > 0)) &&
+        dest_node.in_subtree_of?(node)
+      styles << 'webgen-menu-item-selected' if node == dest_node
+      style = "class=\"#{styles.join(' ')}\"" if styles.length > 0
+
+      link = dest_node.link_to(node, :lang => lang)
+
+      [style, link]
+    end
+
+    # Return the menu tree for the language +lang+.
+    def menu_tree_for_lang(lang, root)
+      menus = (website.cache.volatile[:menutrees] ||= {})
+      unless menus[lang]
+        menus[lang] = create_menu_tree(root, nil, lang)
+        menus[lang].sort! if menus[lang]
+      end
+      menus[lang]
+    end
+
+    # Create and return a menu tree if at least one node is in the menu or +nil+ otherwise.
+    def create_menu_tree(node, parent, lang)
+      menu_node = MenuNode.new(parent, node)
+
+      node.children.select do |child|
+        child.lang == lang || child.lang.nil? || child.is_directory?
+      end.each do |child|
+        sub_node = create_menu_tree(child, menu_node, lang)
+        menu_node.children << sub_node unless sub_node.nil?
+      end
+      menu_node.is_in_tree_of_files = (!node.is_fragment? && node['in_menu']) || menu_node.children.any? {|c| c.is_in_tree_of_files?}
+
+      menu_node.children.empty? ? (node['in_menu'] ? menu_node : nil) : menu_node
+    end
+
+  end
+
+end

data/lib/webgen/tag/metainfo.rb

@@ -0,0 +1,25 @@
+require 'webgen/tag'
+
+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
+      else
+        log(:warn) { "No value for meta info key '#{tag}' in <#{context.ref_node.absolute_lcn}> found in <#{context.content_node.absolute_lcn}>" }
+      end
+      output
+    end
+
+  end
+
+end

data/lib/webgen/tag/relocatable.rb

@@ -0,0 +1,53 @@
+require 'webgen/tag'
+require 'uri'
+
+module Webgen::Tag
+
+  # Makes a path relative. This is very useful for templates. For example, you normally include a
+  # stylesheet in a template. If you specify the filename of the stylesheet directly, the reference
+  # to the stylesheet in the output file of a page file that is not in the same directory as the
+  # template would be invalid.
+  #
+  # By using the +relocatable+ tag you ensure that the path stays valid.
+  class Relocatable
+
+    include Webgen::Tag::Base
+
+    # Return the relativized path for the path provided in the tag definition.
+    def call(tag, body, context)
+      uri_string = param('tag.relocatable.path')
+      result = ''
+      unless uri_string.nil?
+        begin
+          uri = URI.parse(uri_string)
+          if uri.absolute?
+            result = uri_string
+          else
+            result = resolve_path(uri_string, context)
+          end
+          if result.empty?
+            log(:error) { "Could not resolve path '#{uri_string}' in <#{context.ref_node.absolute_lcn}>" }
+            context.dest_node.dirty = true
+          end
+        rescue URI::InvalidURIError => e
+          log(:error) { "Error while parsing path for tag relocatable in <#{context.ref_node.absolute_lcn}>: #{e.message}" }
+          context.dest_node.dirty = true
+        end
+      end
+      result
+    end
+
+    #######
+    private
+    #######
+
+    # Resolve the path +uri+ using the reference node and return the correct relative path from the
+    # destination node.
+    def resolve_path(uri, context)
+      dest_node = context.ref_node.resolve(uri, context.dest_node.lang)
+      (dest_node ? context.dest_node.route_to(dest_node) : '')
+    end
+
+  end
+
+end