webgen 0.5.2 → 0.5.3

data/lib/webgen/sourcehandler/feed.rb

@@ -0,0 +1,121 @@
+require 'webgen/websiteaccess'
+require 'webgen/sourcehandler/base'
+
+module Webgen::SourceHandler
+
+  # Source handler for creating atom and/or rss feeds.
+  class Feed
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    # The mandatory keys that need to be set in a feed file.
+    MANDATORY_INFOS = %W[site_url author entries]
+
+    def initialize # :nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
+
+    # Create atom and/or rss feed files from +parent+ and +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      path.meta_info['link'] ||= parent.absolute_lcn
+
+      if MANDATORY_INFOS.any? {|t| path.meta_info[t].nil?}
+        raise "One of #{MANDATORY_INFOS.join('/')} information missing for feed <#{path}>"
+      end
+
+      create_feed_node = lambda do |type|
+        path.ext = type
+        super(parent, path) do |node|
+          node.node_info[:feed] = page
+          node.node_info[:feed_type] = type
+        end
+      end
+
+      nodes = []
+      nodes << create_feed_node['atom'] if path.meta_info['atom']
+      nodes << create_feed_node['rss'] if path.meta_info['rss']
+
+      nodes
+    end
+
+    # Return the rendered feed represented by +node+.
+    def content(node)
+      website.cache[[:sourcehandler_feed, node.node_info[:src]]] = feed_entries(node).map {|n| n.absolute_lcn}
+      block_name = node.node_info[:feed_type] + '_template'
+      if node.node_info[:feed].blocks.has_key?(block_name)
+        node.node_info[:feed].blocks[block_name].
+          render(Webgen::ContentProcessor::Context.new(:chain => [node])).content
+      else
+        feed = (website.cache.volatile[:sourcehandler_feed] ||= {})[node.node_info[:src]] ||= build_feed_for(node)
+        feed.feed_type = node.node_info[:feed_type]
+        feed.build_xml
+      end
+    end
+
+    # Helper method for returning the entries for the feed node +node+.
+    def feed_entries(node)
+      nr_items = (node['number_of_entries'].to_i == 0 ? 10 : node['number_of_entries'].to_i)
+      patterns = [node['entries']].flatten.map {|pat| Pathname.new(pat =~ /^\// ? pat : File.join(node.parent.absolute_lcn, pat)).cleanpath.to_s}
+
+      node.tree.node_access[:alcn].values.
+        select {|node| patterns.any? {|pat| node =~ pat} && node.node_info[:page]}.
+        sort {|a,b| a['modified_at'] <=> b['modified_at']}.
+        reverse[0, nr_items]
+    end
+
+    #######
+    private
+    #######
+
+    # Return the populated FeedTools::Feed object for +node+.
+    def build_feed_for(node)
+      require 'feed_tools'
+      require 'time'
+
+      site_url = node['site_url']
+
+      feed = FeedTools::Feed.new
+      feed.title = node['title']
+      feed.description = node['description']
+      feed.author = node['author']
+      feed.author.url = node['author_url']
+      feed.base_uri = site_url
+      feed.link = File.join(site_url, node.tree[node['link']].path)
+      feed.id = feed.link
+
+      feed.published = (node['created_at'].kind_of?(Time) ? node['created_at'] : Time.now)
+      feed.updated = Time.now
+      feed.generator = 'webgen - Webgen::SourceHandler::Feed'
+      feed.icon = File.join(site_url, node.tree[node['icon']].path) if node['icon']
+
+      node.feed_entries.each do |entry|
+        item = FeedTools::FeedItem.new
+        item.title = entry['title']
+        item.link = File.join(site_url, entry.path)
+        item.content = entry.node_info[:page].blocks['content'].render(Webgen::ContentProcessor::Context.new(:chain => [entry])).content
+        item.updated = entry['modified_at']
+        item.published = entry['created_at'] if entry['created_at'].kind_of?(Time)
+        if entry['author']
+          item.author = entry['author']
+          item.author.url = entry['author_url']
+        end
+        item.id = item.link
+        feed << item
+      end
+      feed
+    end
+
+    # Check if the +node+ has meta information from any meta info node and if so, if the meta info
+    # node in question has changed.
+    def node_changed?(node)
+      return if node.node_info[:processor] != self.class.name
+      entries = node.feed_entries
+      node.dirty = true if entries.map {|n| n.absolute_lcn } != website.cache[[:sourcehandler_feed, node.node_info[:src]]] ||
+        entries.any? {|n| n.changed?}
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/metainfo.rb

@@ -15,7 +15,7 @@ module Webgen::SourceHandler
 
     # Upon creation the object registers itself as listener for some node hooks.
     def initialize
-      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+      website.blackboard.add_listener(:node_meta_info_changed?, method(:node_meta_info_changed?))
       website.blackboard.add_listener(:before_node_created, method(:before_node_created))
       website.blackboard.add_listener(:before_node_deleted, method(:before_node_deleted))
       website.blackboard.add_listener(:after_node_created, method(:after_node_created))
@@ -30,9 +30,14 @@ module Webgen::SourceHandler
           node.node_info[mi_key] = {}
           YAML::load(page.blocks[block_name].content).each do |key, value|
             key = Pathname.new(key =~ /^\// ? key : File.join(parent.absolute_lcn, key)).cleanpath.to_s
-            node.node_info[mi_key][key.chomp('/')] = value
+            key.chomp('/') unless key == '/'
+            node.node_info[mi_key][key] = value
           end if page.blocks.has_key?(block_name)
         end
+        website.cache[[:sh_metainfo_node_mi, node.absolute_lcn]] = {
+          :mi_paths => node.node_info[:mi_paths],
+          :mi_alcn => node.node_info[:mi_alcn]
+        }
 
         mark_all_matched_dirty(node)
 
@@ -53,13 +58,20 @@ module Webgen::SourceHandler
     private
     #######
 
+    # Return +true+ if any meta information for +node+ provided by +mi_node+ has changed.
+    def meta_info_changed?(mi_node, node, use_cache = true)
+      use_cache = false if !website.cache.old_data[[:sh_metainfo_node_mi, mi_node.absolute_lcn]]
+      cached = website.cache[[:sh_metainfo_node_mi, mi_node.absolute_lcn]]
+      path = website.blackboard.invoke(:source_paths)[node.node_info[:src]]
+      (mi_node.node_info[:mi_paths].any? {|pattern, mi| path =~ pattern && (!use_cache || mi != cached[:mi_paths][pattern])} ||
+       mi_node.node_info[:mi_alcn].any? {|pattern, mi| node =~ pattern && (!use_cache || mi != cached[:mi_alcn][pattern])})
+    end
+
     # Mark all nodes that are matched by a path or an alcn specifcation in the meta info node +node+
     # as dirty.
-    def mark_all_matched_dirty(node)
-      source_paths = website.blackboard.invoke(:source_paths)
+    def mark_all_matched_dirty(node, use_cache = true)
       node.tree.node_access[:alcn].each do |path, n|
-        n.dirty = true if node.node_info[:mi_paths].any? {|pattern, mi| source_paths[n.node_info[:src]] =~ pattern }
-        n.dirty = true if node.node_info[:mi_alcn].any? {|pattern, mi| n =~ pattern }
+        n.dirty_meta_info = true if meta_info_changed?(node, n, use_cache)
       end
     end
 
@@ -83,14 +95,11 @@ module Webgen::SourceHandler
 
     # Check if the +node+ has meta information from any meta info node and if so, if the meta info
     # node in question has changed.
-    def node_changed?(node)
+    def node_meta_info_changed?(node)
       return if self.nodes.include?(node)
-      path = website.blackboard.invoke(:source_paths)[node.node_info[:src]]
       self.nodes.each do |n|
-        if n.changed? &&
-            (n.node_info[:mi_paths].any? {|pattern, mi| path =~ pattern} ||
-             n.node_info[:mi_alcn].any? {|pattern, mi| node =~ pattern})
-          node.dirty = true
+        if n.created && meta_info_changed?(n, node)
+          node.dirty_meta_info = true
           return
         end
       end
@@ -99,7 +108,7 @@ module Webgen::SourceHandler
     # Delete the meta info node +node+ from the internal array.
     def before_node_deleted(node)
       return unless node.node_info[:processor] == self.class.name
-      mark_all_matched_dirty(node)
+      mark_all_matched_dirty(node, false) if !website.blackboard.invoke(:source_paths).include?(node.node_info[:src])
       self.nodes.delete(node)
     end
 

data/lib/webgen/sourcehandler/page.rb

@@ -65,9 +65,11 @@ module Webgen::SourceHandler
     def meta_info_changed?(node)
       return if !node.created || node.node_info[:processor] != self.class.name
       ckey = [:sh_page_node_mi, node.absolute_lcn]
-      if website.cache.old_data[ckey]  != website.cache.new_data[ckey]
-        node.dirty_meta_info = true
-      end
+      old_mi = website.cache.old_data[ckey]
+      old_mi.delete('modified_at') if old_mi
+      new_mi = website.cache.new_data[ckey]
+      new_mi.delete('modified_at')
+      node.dirty_meta_info = true if old_mi != new_mi
     end
 
   end

data/lib/webgen/sourcehandler/sitemap.rb

@@ -0,0 +1,60 @@
+require 'webgen/websiteaccess'
+require 'webgen/sourcehandler/base'
+require 'uri'
+require 'time'
+
+module Webgen::SourceHandler
+
+  # Source handler for creating an XML sitemap based on the specification of http://sitemaps.org.
+  #
+  # Uses Webgen::Common::Sitemap to generate the needed sitemap tree and to check if a sitemap has
+  # changed.
+  class Sitemap
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    # Create an XML sitemap from +parent+ and +path+.
+    def create_node(parent, path)
+      page_from_path(path)
+      path.ext = 'xml'
+      raise "Needed information site_url missing for sitemap <#{path}>" if path.meta_info['site_url'].nil?
+      super(parent, path)
+    end
+
+    # Return the rendered feed represented by +node+.
+    def content(node)
+      require 'builder'
+      list = website.blackboard.invoke(:create_sitemap, node, node.lang, options_for_node(node)).to_lcn_list.flatten
+      sitemap = ::Builder::XmlMarkup.new(:indent => 2)
+      sitemap.instruct!(:xml, :version => '1.0', :encoding => 'UTF-8')
+      sitemap.urlset(:xmlns => "http://www.sitemaps.org/schemas/sitemap/0.9") do
+        list.each do |alcn|
+          item = node.tree[alcn]
+          sitemap.url do |url|
+            sitemap.loc(URI.escape(File.join(node['site_url'], item.path)))
+            sitemap.lastmod(item['modified_at'].iso8601)
+            changefreq = item['change_freq'] || node['default_change_freq']
+            sitemap.changefreq(changefreq) if changefreq
+            priority = item['priority'] || node['default_priority']
+            sitemap.priority(priority) if priority
+          end
+        end
+      end
+      sitemap.target!
+    end
+
+    #######
+    private
+    #######
+
+    # Return a hash with the sitemap-creation-options set on the +node+.
+    def options_for_node(node)
+      options = {}
+      node.meta_info.each {|k,v| options[k] = v if k =~ /\./}
+      options
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/template.rb

@@ -35,7 +35,11 @@ module Webgen::SourceHandler
         template_node = cached_template[lang] = nil
       else
         log(:info) { "Using default template in language '#{lang}' for <#{node.absolute_lcn}>" }
-        template_node = cached_template[lang] = default_template(node.parent, lang)
+        template_node = default_template(node.parent, lang)
+        if template_node == node && !node.parent.is_root?
+          template_node = default_template(node.parent.parent, lang)
+        end
+        cached_template[lang] = template_node
       end
 
       if template_node.nil?

data/lib/webgen/sourcehandler/virtual.rb

@@ -23,6 +23,7 @@ module Webgen::SourceHandler
 
         temp_path = Webgen::Path.new(key)
         temp_path.meta_info.update(value || {})
+        temp_path.meta_info['modified_at'] = path.meta_info['modified_at']
         temp_path.meta_info['no_output'] = true
         output_path = temp_path.meta_info.delete('url') || key
         output_path = (output_path =~ /^\// ? output_path : File.join(temp_parent.absolute_lcn, output_path))

data/lib/webgen/tag.rb

@@ -16,6 +16,7 @@ module Webgen
     autoload :ExecuteCommand, 'webgen/tag/executecommand'
     autoload :Coderay, 'webgen/tag/coderay'
     autoload :Date, 'webgen/tag/date'
+    autoload :Sitemap, 'webgen/tag/sitemap'
 
   end
 

data/lib/webgen/tag/breadcrumbtrail.rb

@@ -1,3 +1,4 @@
+require 'webgen/websiteaccess'
 require 'webgen/tag'
 
 module Webgen::Tag
@@ -6,13 +7,31 @@ module Webgen::Tag
   # hierarchies of directories.
   class BreadcrumbTrail
 
-    include Webgen::Tag::Base
+    include Webgen::WebsiteAccess
+    include Base
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
 
     # Create the breadcrumb trail.
     def call(tag, body, context)
-      out = []
-      node = context.content_node
+      out = breadcrumb_trail_list(context.content_node)
+      (context.dest_node.node_info[:tag_breadcrumb_trail] ||= {})[[@params.to_a.sort, context.content_node.absolute_lcn]] = out.map {|n| n.absolute_lcn}
+      out = out.map {|n| context.dest_node.link_to(n, :lang => context.content_node.lang) }.
+        join(param('tag.breadcrumbtrail.separator'))
+      log(:debug) { "Breadcrumb trail for <#{context.content_node.absolute_lcn}>: #{out}" }
+      out
+    end
+
+    #######
+    private
+    #######
 
+    # Return the list of nodes that make up the breadcrumb trail of +node+ according to the current
+    # parameters.
+    def breadcrumb_trail_list(node)
+      list = []
       omit_index_path = if node.meta_info.has_key?('omit_index_path')
                           node['omit_index_path']
                         else
@@ -23,15 +42,28 @@ module Webgen::Tag
       node = node.parent if omit_index_path
 
       until node == node.tree.dummy_root
-        context.dest_node.node_info[:used_meta_info_nodes] << node.routing_node(context.dest_node.lang).absolute_lcn
-        context.dest_node.node_info[:used_meta_info_nodes] << node.absolute_lcn
-        out.push(context.dest_node.link_to(node.in_lang(context.content_node.lang)))
+        list.unshift(node)
         node = node.parent
       end
-      out[0] = '' if param('tag.breadcrumbtrail.omit_last') && !omit_index_path
-      out = out.reverse.join(param('tag.breadcrumbtrail.separator'))
-      log(:debug) { "Breadcrumb trail for <#{context.dest_node.absolute_lcn}>: #{out}" }
-      out
+      list[param('tag.breadcrumbtrail.start_level')..param('tag.breadcrumbtrail.end_level')].to_a
+    end
+
+    # Check if the breadcrumb trails for +node+ have changed.
+    def node_changed?(node)
+      return if !node.node_info[:tag_breadcrumb_trail]
+
+      node.node_info[:tag_breadcrumb_trail].each do |(params, cn_alcn), cached_list|
+        cn = node.tree[cn_alcn]
+        set_params(params.to_hash)
+        list = breadcrumb_trail_list(cn)
+        set_params({})
+
+        if (list.map {|n| n.absolute_lcn} != cached_list) ||
+            list.any? {|n| (r = n.routing_node(cn.lang)) && r != node && r.meta_info_changed?}
+          node.dirty = true
+          break
+        end
+      end
     end
 
   end

data/lib/webgen/tag/langbar.rb

@@ -20,7 +20,7 @@ module Webgen::Tag
       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)}.
+        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

data/lib/webgen/tag/menu.rb

@@ -58,12 +58,8 @@ module Webgen::Tag
     def call(tag, body, context)
       tree = specific_menu_tree_for(context.content_node)
 
-      (context.dest_node.node_info[:tag_menu_menus] ||= []) << [@params, context.content_node.absolute_lcn, (tree ? tree.to_lcn_list : nil)]
-      if tree && !tree.children.empty?
-        "<div class=\"webgen-menu\">#{create_output(context, tree)}</div>"
-      else
-        ""
-      end
+      (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
 
     #########
@@ -75,11 +71,11 @@ module Webgen::Tag
       return if !node.node_info[:tag_menu_menus] || @inside_node_changed
 
       @inside_node_changed = true  #TODO: better solution for this race condition?
-      node.node_info[:tag_menu_menus].each do |params, cn_alcn, cached_tree|
+      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)
+        set_params(params.to_hash)
         tree = build_specific_menu_tree(cn, menu_tree)
         tree_list = tree.to_lcn_list if tree
         set_params({})
@@ -134,11 +130,11 @@ module Webgen::Tag
     end
 
     # Create the HTML menu of the +tree+ using the provided +context+.
-    def create_output(context, tree)
+    def create_output(context, tree, level = 1)
       out = "<ul>"
       tree.children.each do |child|
-        menu = child.children.length > 0 ? create_output(context, child) : ''
-        style, link = menu_item_details(context.dest_node, child.node, context.content_node.lang)
+        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
@@ -149,15 +145,15 @@ module Webgen::Tag
     end
 
     # Return style information (node is selected, ...) and a link from +dest_node+ to +node+.
-    def menu_item_details(dest_node, node, lang)
-      styles = []
+    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)
+      link = dest_node.link_to(node, :lang => lang)
 
       [style, link]
     end