webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/tag/date.rb

@@ -1,18 +1,18 @@
 # -*- encoding: utf-8 -*-
 
-module Webgen::Tag
+module Webgen
+  class 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
+    # Prints out the date using a format string which will be passed to Time#strftime. Therefore you
+    # can use everything Time#strftime offers.
+    module Date
 
-    include Base
+      # Return the current date formatted as specified.
+      def self.call(tag, body, context)
+        Time.now.strftime(context[:config]['tag.date.format'])
+      end
 
-    # 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/execute_command.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'cgi'
+require 'tempfile'
+require 'rbconfig'
+
+module Webgen
+  class Tag
+
+    # Executes the given command and returns the standard output. All special HTML characters are
+    # optionally escaped.
+    module ExecuteCommand
+
+      BIT_BUCKET = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ?  "nul" : "/dev/null")
+
+      # Execute the command and return the standard output.
+      def self.call(tag, body, context)
+        command = context[:config]['tag.execute_command.command']
+        output = `#{command} 2> #{BIT_BUCKET}`
+        if $?.exitstatus != 0
+          raise Webgen::RenderError.new("Command '#{command}' has return value != 0: #{output}",
+                                        self.name, context.dest_node, context.ref_node)
+        end
+        output = CGI::escapeHTML(output) if context[:config]['tag.execute_command.escape_html']
+        [output, context[:config]['tag.execute_command.process_output']]
+      end
+
+    end
+
+  end
+end

data/lib/webgen/tag/include_file.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+require 'cgi'
+
+module Webgen
+  class Tag
+
+    # Includes a file verbatim and optionally escapes all special HTML characters and/or processes
+    # webgen tags in it.
+    module IncludeFile
+
+      # Include the specified file verbatim in the output, optionally escaping special HTML characters
+      # and/or processing tags in it.
+      def self.call(tag, body, context)
+        filename = context[:config]['tag.include_file.filename']
+        filename = File.join(context.website.directory, filename) unless filename =~ /^(\/|\w:)/
+        if !File.exists?(filename)
+          raise Webgen::RenderError.new("File '#{filename}' cannot be included because it does not exist",
+                                        self.name, context.dest_node, context.ref_node)
+        end
+
+        content = File.read(filename)
+        content = CGI::escapeHTML(content) if context[:config]['tag.include_file.escape_html']
+        context.website.ext.item_tracker.add(context.dest_node, :file, filename)
+
+        [content, context[:config]['tag.include_file.process_output']]
+      end
+
+    end
+
+  end
+end

data/lib/webgen/tag/langbar.rb

@@ -1,55 +1,39 @@
 # -*- encoding: utf-8 -*-
 
-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.acn] = lang_nodes.map {|n| n.alcn}
-      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 do |n|
-        attrs = {:link_text => (param('tag.langbar.lang_names')[n.lang] || n.lang), :lang => n.lang}
-        attrs['class'] = 'webgen-langbar-current-lang' if context.content_node.lang == n.lang
-        context.dest_node.link_to(n, attrs)
-      end.join(param('tag.langbar.separator'))
-
-      [(param('tag.langbar.show_single_lang') || lang_nodes.length > 1 ? result : ""), param('tag.langbar.process_output')]
-    end
-
-    #######
-    private
-    #######
-
-    # Return all nodes with the same absolute cn as +node+.
-    def all_lang_nodes(node)
-      node.tree.node_access[:acn][node.acn]
-    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.flag(:dirty)
-          break
+require 'webgen/tag'
+
+module Webgen
+  class Tag
+
+    # Generates a list with all the languages of the page.
+    module Langbar
+
+      # Return a rendering of the list of all translations of the content node.
+      def self.call(tag, body, context)
+        context.website.ext.item_tracker.add(context.dest_node, :nodes,
+                                             ['Webgen::Tag::Langbar', 'node_translations'],
+                                             context.content_node.alcn, :meta_info)
+        nodes = node_translations(context.website, context.content_node.alcn)
+
+        if context[:config]['tag.langbar.show_single_lang'] || nodes.length > 1
+          context[:nodes] = nodes.
+            reject {|n| (context.content_node.lang == n.lang && !context[:config]['tag.langbar.show_own_lang'])}.
+            sort {|a, b| a.lang <=> b.lang}
+          Webgen::Tag.render_tag_template(context, 'langbar')
+        else
+          ''
         end
       end
+
+      # Generate the list of node translations given the options.
+      #
+      # This method is invoked by Webgen::ItemTracker::NodeList to retrieve the translations nodes
+      # when necessary.
+      def self.node_translations(website, node_alcn)
+        website.tree.translations(website.tree[node_alcn])
+      end
+
     end
 
   end
-
 end

data/lib/webgen/tag/link.rb

@@ -1,27 +1,26 @@
 # -*- encoding: utf-8 -*-
 
-module Webgen::Tag
+module Webgen
+  class Tag
 
-  # Create a link to a given (A)LCN.
-  class Link
+    # Create a link to a given (A)LCN.
+    module 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').to_s, context.dest_node.lang))
-        context.dest_node.node_info[:used_meta_info_nodes] << dest_node.alcn
-        context.dest_node.link_to(dest_node, param('tag.link.attr').merge(:lang => context.content_node.lang))
-      else
-        log(:error) { "Could not resolve path '#{param('tag.link.path')}' in <#{context.ref_node}>" }
-        context.dest_node.flag(:dirty)
-        ''
+      # Return an HTML link to the given (A)LCN.
+      def self.call(tag, body, context)
+        path = context[:config]['tag.link.path'].to_s
+        if (dest_node = context.ref_node.resolve(path, context.dest_node.lang, true))
+          context.website.ext.item_tracker.add(context.dest_node, :node_meta_info, dest_node.alcn)
+          context.dest_node.link_to(dest_node, context.content_node.lang, context[:config]['tag.link.attr'])
+        else
+          ''
+        end
+      rescue URI::InvalidURIError => e
+        raise Webgen::RenderError.new("Error while parsing path '#{path}': #{e.message}",
+                                      self.name, context.dest_node, context.ref_node)
       end
-    rescue URI::InvalidURIError => e
-      raise Webgen::RenderError.new("Error while parsing path '#{param('tag.link.path')}': #{e.message}",
-                                    self.class.name, context.dest_node, context.ref_node)
+
     end
 
   end
-
 end

data/lib/webgen/tag/menu.rb

@@ -1,207 +1,45 @@
 # -*- encoding: utf-8 -*-
 
-module Webgen::Tag
+require 'webgen/tag'
 
-  # Generates a menu that can be configured extensively.
-  class Menu
+module Webgen
+  class Tag
 
-    include Webgen::WebsiteAccess
-    include Base
+    # Generates a menu that can be extensively configured by using the available Webgen::NodeFinder
+    # options.
+    module Menu
 
-    # Special menu node class. It encapsulates the original node for later access.
-    class MenuNode
+      # Generate the menu.
+      def self.call(tag, body, context)
+        options = context[:config]['tag.menu.options']
 
-      # Array of the child nodes.
-      attr_reader :children
+        context[:nodes] = context.website.ext.node_finder.find(options, context.content_node)
+        context.website.ext.item_tracker.add(context.dest_node, :nodes, :node_finder_option_set,
+                                             {:opts => options, :ref_alcn => context.content_node.alcn}, :meta_info)
 
-      # 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.alcn; 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.alcn]] = (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
+        if context[:nodes].empty?
+          ''
+        else
+          Webgen::Tag.render_tag_template(context, "menu")
         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
+      # Return style information (node is selected, ...) and a link from +dest_node+ to +node+.
+      #
+      # This method can be used in a menu template.
+      def self.menu_item_details(dest_node, node, lang, level, has_submenu)
+        styles = ['webgen-menu-level' + level.to_s]
+        styles << 'webgen-menu-submenu' if has_submenu
+        styles << 'webgen-menu-submenu-inhierarchy' if has_submenu && node.is_ancestor_of?(dest_node)
+        styles << 'webgen-menu-item-selected' if node == dest_node
+        style = "class=\"#{styles.join(' ')}\"" if styles.length > 0
 
-      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
+        link = dest_node.link_to(node, lang)
 
-      if level < param('tag.menu.start_level')
-        sub_menu_tree
-      else
-        menu_tree
+        [style, link]
       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