webgen 0.5.5 → 0.5.6

data/lib/webgen/sourcehandler/base.rb

@@ -1,3 +1,4 @@
+require 'facets/symbol/to_proc'
 require 'webgen/websiteaccess'
 require 'webgen/loggable'
 require 'webgen/page'
@@ -42,9 +43,18 @@ module Webgen::SourceHandler
   # <tt>node_info[:processor]</tt>:: Has to be set to the class name of the source handler. This is
   #                                  used by the Node class: all unknown method calls are forwarded
   #                                  to the node processor.
-  # <tt>node_info[:src]</tt>:: Has to be set to the string version of the source path.
+  # <tt>node_info[:src]</tt>:: Has to be set to the string version of the path that lead to the
+  #                            creation of the node.
+  # <tt>node_info[:creation_path]</tt>:: Has to be set to the string version of the path that is
+  #                                      used to create the path.
   # <tt>meta_info['no_output']</tt>:: Has to be set to +true+ on nodes that are used during a
   #                                   webgen run but do not produce an output file.
+  # <tt>meta_info['modified_at']</tt>:: Is automatically set to the current time if not already set
+  #                                     correctly (ie. if not a Time object).
+  #
+  # Note: The difference between +:src+ and +:creation_path+ is that a creation path need not have
+  # an existing source path representation. For example, fragments created from a page source path
+  # have a different +:creation_path+ which includes the fragment part.
   #
   # Additional information that is used only for processing purposes should be stored in the
   # #node_info hash of a node as the #meta_info hash is reserved for real node meta information and
@@ -55,7 +65,8 @@ module Webgen::SourceHandler
   # Path patterns define which paths are handled by a specific source handler. These patterns are
   # specified in the <tt>sourcehandler.patterns</tt> configuration hash as a mapping from the source
   # handler class name to an array of path patterns. The patterns need to have a format that
-  # <tt>Dir.glob</tt> can handle.
+  # <tt>Dir.glob</tt> can handle. You can use the configuration helper +patterns+ to set this (is
+  # shown in the example below).
   #
   # Specifying a path pattern does not mean that webgen uses the source handler. One also needs to
   # provide an entry in the configuration value <tt>sourcehandler.invoke</tt>. This is a hash that
@@ -97,7 +108,7 @@ module Webgen::SourceHandler
   #
   #   end
   #
-  #   WebsiteAccess.website.config.sourcehandler.patterns['SimpleCopy'] = ['**/*.jpg', '**/*.png']
+  #   WebsiteAccess.website.config.patterns('SimpleCopy' => ['**/*.jpg', '**/*.png'])
   #   WebsiteAccess.website.config.sourcehandler.invoke[5] << 'SimpleCopy'
   #
   module Base
@@ -153,10 +164,12 @@ module Webgen::SourceHandler
                         Webgen::WebsiteAccess.website.config['sourcehandler.default_lang_in_output_path'] ||
                           Webgen::WebsiteAccess.website.config['website.lang'] != path.meta_info['lang']
                       end
-      if OutputPathHelpers.public_instance_methods(false).include?(method)
+      if OutputPathHelpers.public_instance_methods(false).map(&:to_s).include?(method)
         name = send(method, parent, path, use_lang_part)
         name += '/'  if path.path =~ /\/$/ && name !~ /\/$/
-        if node_exists?(parent, path, name)
+        if (node = node_exists?(parent, path, name)) && node.lang == path.meta_info['lang']
+          name = node.path
+        elsif node
           name = send(method, parent, path, (path.meta_info['lang'].nil? ? false : true))
           name += '/'  if path.path =~ /\/$/ && name !~ /\/$/
         end
@@ -172,21 +185,31 @@ module Webgen::SourceHandler
       parent.tree[Webgen::Node.absolute_name(parent, path.lcn, :alcn)] || (!path.meta_info['no_output'] && parent.tree[output_path, :path])
     end
 
-    # Create and return a node under +parent+ from +path+ if it does not already exists. Some
+    # Create a node under +parent+ from +path+ if it does not already exists or needs to be
+    # re-initialized. The found node or the newly created node is returned afterwards. +nil+ is
+    # returned if no node can be created (e.g. when <tt>path.meta_info['draft']</tt> is set). Some
     # additional node information like <tt>:src</tt> and <tt>:processor</tt> is set and the meta
-    # information is checked for validness. The created node is yielded if a block is given.
+    # information is checked for validness. The created/re-initialized node is yielded if a block is
+    # given.
     def create_node(parent, path, output_path = self.output_path(parent, path))
-      return if path.meta_info['draft']
-      if !node_exists?(parent, path, output_path)
+      return nil if path.meta_info['draft']
+      node = node_exists?(parent, path, output_path)
+      if node && (node.node_info[:src] != path.source_path || node.node_info[:processor] != self.class.name)
+        log(:warn) { "Node already exists: source = #{path.source_path} | path = #{node.path} | alcn = #{node.absolute_lcn}"}
+        return node
+      elsif !node
         node = Webgen::Node.new(parent, output_path, path.cn, path.meta_info)
-        node['modified_at'] = Time.now unless node['modified_at'].kind_of?(Time)
-        node.node_info[:src] = path.path
-        node.node_info[:processor] = self.class.name
-        yield(node) if block_given?
-        node
+      elsif node.flagged(:reinit)
+        node.reinit(output_path, path.meta_info)
       else
-        log(:warn) { "Node already exists: output path = #{output_path} | alcn = #{Webgen::Node.absolute_name(parent, path.lcn, :alcn)}"}
+        return node
       end
+      node['modified_at'] = Time.now unless node['modified_at'].kind_of?(Time)
+      node.node_info[:src] = path.source_path
+      node.node_info[:creation_path] = path.path
+      node.node_info[:processor] = self.class.name
+      yield(node) if block_given?
+      node
     end
 
     # Return the content of the given +node+. This default +content+ method just returns +nil+.

data/lib/webgen/sourcehandler/copy.rb

@@ -7,8 +7,8 @@ module Webgen::SourceHandler
     include Webgen::WebsiteAccess
     include Base
 
-    # Create the node for +parent+ and +path+. If the +path+ has the name of a content processor in
-    # the extension, it is preprocessed.
+    # Create the node for +parent+ and +path+. If the +path+ has the name of a content processor as
+    # the first part in the extension, it is preprocessed.
     def create_node(parent, path)
       if path.ext.index('.')
         processor, *rest = path.ext.split('.')

data/lib/webgen/sourcehandler/directory.rb

@@ -1,24 +1,27 @@
-require 'webgen/sourcehandler/base'
-
 module Webgen::SourceHandler
 
   # Handles directory source paths.
   class Directory
 
     include Base
+    include Webgen::WebsiteAccess
+
+    def initialize # :nodoc:
+      website.blackboard.add_service(:create_directories, method(:create_directories))
+    end
 
-    # Creation of directory nodes is special because once they are created, they are only deleted
-    # when the source path gets deleted. Otherwise, only the meta information of the node gets
-    # updated.
-    def create_node(parent, path)
-      if node = node_exists?(parent, path)
-        node.meta_info.clear
-        node.meta_info.update(path.meta_info)
-        node.dirty = true
-        node
-      else
-        super(parent, path)
+    # Recursively create the directories specified in +dirname+ under +parent+ (a leading slash is
+    # ignored). The path +path+ is the path that lead to the creation of these directories.
+    def create_directories(parent, dirname, path)
+      dirname.sub(/^\//, '').split('/').each do |dir|
+        dir_path = Webgen::Path.new(File.join(parent.absolute_lcn, dir, '/'), path)
+        nodes = website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
+                                           dir_path, self) do |dir_parent, dir_path|
+          node_exists?(dir_parent, dir_path) || create_node(dir_parent, dir_path)
+        end
+        parent = nodes.first
       end
+      parent
     end
 
     # Return an empty string to signal that the directory should be written to the output.

data/lib/webgen/sourcehandler/feed.rb

@@ -1,6 +1,3 @@
-require 'webgen/websiteaccess'
-require 'webgen/sourcehandler/base'
-
 module Webgen::SourceHandler
 
   # Source handler for creating atom and/or rss feeds.
@@ -49,8 +46,7 @@ module Webgen::SourceHandler
           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
+        feed.build_xml(node.node_info[:feed_type], (node.node_info[:feed_type] == 'rss' ? node['rss_version'] || 2.0 : nil))
       end
     end
 
@@ -61,8 +57,7 @@ module Webgen::SourceHandler
 
       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]
+        sort {|a,b| a['modified_at'] <=> b['modified_at']}[0, nr_items]
     end
 
     #######
@@ -88,13 +83,12 @@ module Webgen::SourceHandler
       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.content = entry.node_info[:page].blocks[node['content_block_name'] || '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']
@@ -107,12 +101,12 @@ module Webgen::SourceHandler
       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.
+    # Check if the any of the nodes used by this feed +node+ have changed and then mark the node as
+    # dirty.
     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]]] ||
+      node.flag(:dirty) if entries.map {|n| n.absolute_lcn } != website.cache[[:sourcehandler_feed, node.node_info[:src]]] ||
         entries.any? {|n| n.changed?}
     end
 

data/lib/webgen/sourcehandler/fragment.rb

@@ -1,6 +1,3 @@
-require 'webgen/sourcehandler/base'
-require 'webgen/websiteaccess'
-
 module Webgen::SourceHandler
 
   # Handles page fragment nodes and provides utility methods for parsing HTML headers and generating
@@ -53,15 +50,13 @@ module Webgen::SourceHandler
     def create_fragment_nodes(sections, parent, path, in_menu, si = 1000 )
       sections.each do |level, id, title, sub_sections|
         node = website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
-                                         path, self) do |cn_parent, cn_path|
-          ptemp = Webgen::Path.new('#' + id)
-          ptemp.meta_info = cn_path.meta_info.merge(ptemp.meta_info)
-          create_node(cn_parent, ptemp)
+                                         Webgen::Path.new('#' + id, path.source_path),
+                                         self) do |cn_parent, cn_path|
+          cn_path.meta_info['title'] = title
+          cn_path.meta_info['in_menu'] = in_menu
+          cn_path.meta_info['sort_info'] = si = si.succ
+          create_node(cn_parent, cn_path)
         end.first
-        node['title'] = title
-        node['in_menu'] = in_menu
-        node['sort_info'] = si = si.succ
-        node.node_info[:src] = path.path
         create_fragment_nodes(sub_sections, node, path, in_menu, si.succ)
       end
     end

data/lib/webgen/sourcehandler/memory.rb

@@ -0,0 +1,41 @@
+module Webgen::SourceHandler
+
+  # This source handler should be used for handling nodes that are created during the write
+  # phase.
+  class Memory
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_flagged) do |node, *flags|
+        node.tree[node.node_info[:memory_source_alcn]].flag(:dirty) if node.node_info[:memory_source_alcn]
+      end
+    end
+
+    # Create a node under +parent+ for the +path+. The +source_alcn+ specified the node that creates
+    # this memory node when written. You have two options for providing the content for this node:
+    # either you set +data+ to a string (or a Webgen::Path::SourceIO object) or you provide a block
+    # which takes the created node as argument and return a string (or a Webgen::Path::SourceIO
+    # object).
+    def create_node(parent, path, source_alcn, data = nil)
+      super(parent, path) do |node|
+        node.node_info[:memory_source_alcn] = source_alcn
+        (@data ||= {})[node.absolute_lcn] = lambda { data || yield(node) }
+      end
+    end
+
+    # Return the content of the memory +node+. If the memory node was not created in this webgen
+    # run, it will be flagged for reinitialization (and therefore recreation).
+    def content(node)
+      if @data && @data[node.absolute_lcn]
+        @data[node.absolute_lcn].call
+      else
+        node.flag(:reinit)
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/metainfo.rb

@@ -1,7 +1,5 @@
 require 'pathname'
 require 'yaml'
-require 'webgen/sourcehandler/base'
-require 'webgen/websiteaccess'
 
 module Webgen::SourceHandler
 
@@ -19,7 +17,7 @@ module Webgen::SourceHandler
       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))
-      self.nodes ||= Set.new
+      self.nodes ||= []
     end
 
     # Create a meta info node from +parent+ and +path+.
@@ -30,18 +28,18 @@ 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
-            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]] = {
+
+        mark_all_matched_dirty(node, :no_old_data)
+
+        website.cache.permanent[[: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)
-
-        self.nodes << node
+        self.nodes << node unless self.nodes.include?(node)
         self.nodes = self.nodes.sort_by {|n| n.absolute_lcn}
       end
     end
@@ -59,19 +57,21 @@ module Webgen::SourceHandler
     #######
 
     # 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])})
+    def meta_info_changed?(mi_node, node, option = nil)
+      cached = website.cache.permanent[[:sh_metainfo_node_mi, mi_node.absolute_lcn]]
+      (mi_node.node_info[:mi_paths].any? do |pattern, mi|
+         Webgen::Path.match(node.node_info[:creation_path], pattern) &&
+           (option == :force || (!cached && option == :no_old_data) || mi != cached[:mi_paths][pattern])
+       end || mi_node.node_info[:mi_alcn].any? do |pattern, mi|
+         node =~ pattern && (option == :force || (!cached && option == :no_old_data) || mi != cached[:mi_alcn][pattern])
+       end)
     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, use_cache = true)
+    def mark_all_matched_dirty(node, option = nil)
       node.tree.node_access[:alcn].each do |path, n|
-        n.dirty_meta_info = true if meta_info_changed?(node, n, use_cache)
+        n.flag(:dirty_meta_info) if meta_info_changed?(node, n, option)
       end
     end
 
@@ -79,7 +79,7 @@ module Webgen::SourceHandler
     def before_node_created(parent, path)
       self.nodes.each do |node|
         node.node_info[:mi_paths].each do |pattern, mi|
-          path.meta_info.update(mi) if path =~ pattern
+          path.meta_info.update(mi) if Webgen::Path.match(path, pattern)
         end
       end
     end
@@ -96,10 +96,9 @@ 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_meta_info_changed?(node)
-      return if self.nodes.include?(node)
       self.nodes.each do |n|
-        if n.created && meta_info_changed?(n, node)
-          node.dirty_meta_info = true
+        if n.flagged(:created) && meta_info_changed?(n, node)
+          node.flag(:dirty_meta_info)
           return
         end
       end
@@ -108,7 +107,8 @@ 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, false) if !website.blackboard.invoke(:source_paths).include?(node.node_info[:src])
+      mark_all_matched_dirty(node, :force)
+      website.cache.permanent.delete([:sh_metainfo_node_mi, node.absolute_lcn])
       self.nodes.delete(node)
     end
 

data/lib/webgen/sourcehandler/page.rb

@@ -1,6 +1,3 @@
-require 'webgen/websiteaccess'
-require 'webgen/sourcehandler/base'
-
 module Webgen::SourceHandler
 
   # Source handler for handling content files in Webgen Page Format.
@@ -20,24 +17,8 @@ module Webgen::SourceHandler
       path.ext = 'html' if path.ext == 'page'
 
       super(parent, path) do |node|
-        website.cache[[:sh_page_node_mi, node.absolute_lcn]] = node.meta_info.dup
-
+        node.node_info[:sh_page_node_mi] = Webgen::Page.meta_info_from_data(path.io.data)
         node.node_info[:page] = page
-        tmp_logger = website.logger
-        website.logger = nil    # disabling logging whiling creating fragment nodes
-
-        website.cache.permanent[:page_sections] ||= {}
-        sections = if path.changed? || !website.cache.permanent[:page_sections][node.absolute_lcn]
-                     website.blackboard.invoke(:parse_html_headers, render_node(node, 'content', []))
-                   else
-                     website.cache.permanent[:page_sections][node.absolute_lcn]
-                   end
-        website.cache.permanent[:page_sections][node.absolute_lcn] = sections
-        website.blackboard.invoke(:create_fragment_nodes,
-                                  sections,
-                                  node, website.blackboard.invoke(:source_paths)[path.path],
-                                  node.meta_info['fragments_in_menu'])
-        website.logger = tmp_logger
       end
     end
 
@@ -63,13 +44,12 @@ module Webgen::SourceHandler
 
     # Checks if the meta information provided by the file in Webgen Page Format changed.
     def meta_info_changed?(node)
-      return if !node.created || node.node_info[:processor] != self.class.name
-      ckey = [:sh_page_node_mi, node.absolute_lcn]
-      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
+      path = website.blackboard.invoke(:source_paths)[node.node_info[:src]]
+      return if node.node_info[:processor] != self.class.name || !path.changed?
+
+      old_mi = node.node_info[:sh_page_node_mi]
+      new_mi = Webgen::Page.meta_info_from_data(path.io.data)
+      node.flag(:dirty_meta_info) if old_mi && old_mi != new_mi
     end
 
   end

data/lib/webgen/sourcehandler/sitemap.rb

@@ -1,5 +1,3 @@
-require 'webgen/websiteaccess'
-require 'webgen/sourcehandler/base'
 require 'uri'
 require 'time'
 

data/lib/webgen/sourcehandler/template.rb

@@ -1,7 +1,3 @@
-require 'webgen/websiteaccess'
-require 'webgen/loggable'
-require 'webgen/sourcehandler/base'
-
 module Webgen::SourceHandler
 
   # Source handler for handling template files in Webgen Page Format.