thewoolleyman-webgen 0.5.8.20090419

data/lib/webgen/tag/link.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+module Webgen::Tag
+
+  # Create a link to a given (A)LCN.
+  class Link
+
+    include Webgen::Tag::Base
+
+    # Return a HTML link to the given (A)LCN.
+    def call(tag, body, context)
+      if (dest_node = context.ref_node.resolve(param('tag.link.path'), context.dest_node.lang))
+        context.dest_node.node_info[:used_meta_info_nodes] << dest_node.absolute_lcn
+        context.dest_node.link_to(dest_node, param('tag.link.attr').merge(:lang => context.content_node.lang))
+      else
+        raise ArgumentError, 'Resolving of path failed'
+      end
+    rescue ArgumentError, URI::InvalidURIError => e
+      log(:error) { "Could not link to path '#{param('tag.link.path')}' in <#{context.ref_node.absolute_lcn}>: #{e.message}" }
+      context.dest_node.flag(:dirty)
+      ''
+    end
+
+  end
+
+end

data/lib/webgen/tag/menu.rb

@@ -0,0 +1,207 @@
+# -*- encoding: utf-8 -*-
+
+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)
+
+      if !tree || tree.children.empty?
+        ''
+      elsif param('tag.menu.nested')
+        create_output_nested(context, tree)
+      else
+        create_output_not_nested(context, tree)
+      end
+    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.flag(:dirty)
+          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 nested HTML menu of the +tree+ using the provided +context+.
+    def create_output_nested(context, tree, level = 1)
+      out = "<ul>"
+      tree.children.each do |child|
+        menu = child.children.length > 0 ? create_output_nested(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
+
+    # Create the not nested HTML menu of the +tree+ using the provided +context+.
+    def create_output_not_nested(context, tree, level = 1)
+      submenu = ''
+      out = "<ul>"
+      tree.children.each do |child|
+        submenu << (child.children.length > 0 ? create_output_not_nested(context, child, level + 1) : '')
+        style, link = menu_item_details(context.dest_node, child.node, context.content_node.lang, level)
+
+        out << "<li #{style}>#{link}</li>"
+      end
+      out << "</ul>"
+      out << submenu
+      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 @@
+# -*- encoding: utf-8 -*-
+
+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,54 @@
+# -*- encoding: utf-8 -*-
+
+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.flag(:dirty)
+          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.flag(:dirty)
+        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

data/lib/webgen/tag/sitemap.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+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/tag/tikz.rb

@@ -0,0 +1,119 @@
+# -*- encoding: utf-8 -*-
+
+require 'erb'
+require 'tempfile'
+require 'fileutils'
+
+module Webgen::Tag
+
+  # This tag allows the creation and inclusion of complex graphics using the PGF/TikZ library of
+  # LaTeX. You will need a current LaTeX distribution and the +convert+ utility from ImageMagick.
+  class TikZ
+
+    include Webgen::Tag::Base
+    include Webgen::WebsiteAccess
+
+    LATEX_TEMPLATE = <<EOF
+\\nonstopmode \\documentclass{article} \\usepackage{tikz} \\pagestyle{empty}
+<% if param('tag.tikz.libraries') %>
+\\usetikzlibrary{<%= param('tag.tikz.libraries').join(',') %>}
+<% end %>
+\\begin{document}
+<% if param('tag.tikz.opts') %>
+\\begin{tikzpicture}[<%= param('tag.tikz.opts') %>]
+<% else %>
+\\begin{tikzpicture}
+<% end %>
+<%= body %>
+\\end{tikzpicture}
+\\end{document}
+EOF
+
+    # Create a graphic from the commands in the body of the tag.
+    def call(tag, body, context)
+      path = param('tag.tikz.path')
+      path = Webgen::Common.absolute_path(path, context.ref_node.parent.absolute_lcn)
+
+      mem_handler = website.cache.instance('Webgen::SourceHandler::Memory')
+      src_path = context.ref_node.node_info[:src]
+      parent = website.blackboard.invoke(:create_directories, context.ref_node.tree.root, File.dirname(path), src_path)
+      params = @params
+
+      node = website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
+                                       Webgen::Path.new(path, src_path), mem_handler) do |node_parent, node_path|
+        mem_handler.create_node(node_parent, node_path, context.ref_node.absolute_lcn) do |pic_node|
+          set_params(params)
+          document = ERB.new(LATEX_TEMPLATE).result(binding)
+          pic_path = compile(document, File.extname(path), context)
+          set_params(nil)
+          if pic_path
+            io = Webgen::Path::SourceIO.new { File.open(pic_path, 'rb') }
+          else
+            pic_node.flag(:dirty)
+            nil
+          end
+        end
+      end.first
+      attrs = param('tag.tikz.img_attr').collect {|name,value| "#{name.to_s}=\"#{value}\"" }.sort.unshift('').join(' ')
+      "<img src=\"#{context.dest_node.route_to(node)}\"#{attrs} />"
+    end
+
+    #######
+    private
+    #######
+
+    # Compile the LaTeX +document+ and convert the resulting PDF to the correct output image format
+    # specified by +ext+ (the extension needs to include the dot).
+    def compile(document, ext, context)
+      file = Tempfile.new('webgen-tikz')
+      file.write(document)
+      file.close
+
+      FileUtils.mv(file.path, file.path + '.tex')
+      cmd_prefix = "cd #{File.dirname(file.path)}; "
+      output = `#{cmd_prefix} pdflatex --shell-escape -interaction=batchmode #{File.basename(file.path)}.tex`
+      if $?.exitstatus != 0
+        errors = output.scan(/^!(.*\n.*)/).join("\n")
+        log(:error) { "There was an error creating a TikZ picture in <#{context.ref_node.absolute_lcn}>: #{errors}"}
+        context.dest_node.flag(:dirty)
+        nil
+      else
+        cmd = cmd_prefix + "pdfcrop #{File.basename(file.path)}.pdf #{File.basename(file.path)}.pdf; "
+        return unless run_command(cmd, context)
+
+        render_res, output_res = param('tag.tikz.resolution').split(' ')
+        if param('tag.tikz.transparent') && ext =~ /\.png/i
+          cmd = cmd_prefix +
+            "gs -dSAFER -dBATCH -dNOPAUSE -r#{render_res} -sDEVICE=pngalpha -dGraphicsAlphaBits=4 -dTextAlphaBits=4 " +
+            "-sOutputFile=#{File.basename(file.path)}#{ext} #{File.basename(file.path)}.pdf"
+        else
+          cmd = cmd_prefix + "convert -density #{render_res} #{File.basename(file.path)}.pdf #{File.basename(file.path)}#{ext}"
+        end
+        return unless run_command(cmd, context)
+
+        if render_res != output_res
+          cmd = cmd_prefix + "identify #{File.basename(file.path)}#{ext}"
+          return unless (output = run_command(cmd, context))
+          width, height = output.scan(/\s\d+x\d+\s/).first.strip.split('x').collect {|s| s.to_f * output_res.to_f / render_res.to_f }
+          cmd = cmd_prefix + "convert -resize #{width}x#{height} #{File.basename(file.path)}#{ext} #{File.basename(file.path)}#{ext}"
+          return unless run_command(cmd, context)
+        end
+        file.path + ext
+      end
+    end
+
+    # Runs the command +cmd+ and returns it's output if successful or +nil+ otherwise.
+    def run_command(cmd, context)
+      output = `#{cmd}`
+      if $?.exitstatus != 0
+        log(:error) { "There was an error running a command for a TikZ picture in <#{context.ref_node.absolute_lcn}>: #{output}"}
+        context.dest_node.flag(:dirty)
+        nil
+      else
+        output
+      end
+    end
+
+  end
+
+end