gettalong-webgen 0.5.4.20080929

data/lib/webgen/sourcehandler/copy.rb

@@ -0,0 +1,41 @@
+module Webgen::SourceHandler
+
+  # Simple source handler for copying files from the source tree, either verbatim or by applying a
+  # content processor.
+  class Copy
+
+    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.
+    def create_node(parent, path)
+      if path.ext.index('.')
+        processor, *rest = path.ext.split('.')
+        if website.blackboard.invoke(:content_processor_names).include?(processor)
+          path.ext = rest.join('.')
+        else
+          processor = nil
+        end
+      end
+      super(parent, path) do |node|
+        node.node_info[:preprocessor] = processor
+      end
+    end
+
+    # Return either the preprocessed content of the +node+ or the IO object for the node's source
+    # path depending on the node type.
+    def content(node)
+      io = website.blackboard.invoke(:source_paths)[node.node_info[:src]].io
+      if node.node_info[:preprocessor]
+        context = Webgen::ContentProcessor::Context.new(:content => io.data, :chain => [node])
+        website.blackboard.invoke(:content_processor, node.node_info[:preprocessor]).call(context)
+        context.content
+      else
+        io
+      end
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/directory.rb

@@ -0,0 +1,31 @@
+require 'webgen/sourcehandler/base'
+
+module Webgen::SourceHandler
+
+  # Handles directory source paths.
+  class Directory
+
+    include Base
+
+    # 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)
+      end
+    end
+
+    # Return an empty string to signal that the directory should be written to the output.
+    def content(node)
+      ''
+    end
+
+  end
+
+end

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/fragment.rb

@@ -0,0 +1,71 @@
+require 'webgen/sourcehandler/base'
+require 'webgen/websiteaccess'
+
+module Webgen::SourceHandler
+
+  # Handles page fragment nodes and provides utility methods for parsing HTML headers and generating
+  # fragment nodes from them.
+  class Fragment
+
+    include Base
+    include Webgen::WebsiteAccess
+
+    HTML_HEADER_REGEXP = /<h([123456])(?:>|\s([^>]*)>)(.*?)<\/h\1\s*>/i
+    HTML_ATTR_REGEXP = /\s*(\w+)\s*=\s*('|")([^\2]+)\2\s*/
+
+    # Parse the string +content+ for headers +h1+, ..., +h6+ and return the found, nested sections.
+    #
+    # Only those headers are used which have an +id+ attribute set. The method returns a list of
+    # arrays with entries <tt>level, id, title, sub sections</tt> where <tt>sub sections</tt> is
+    # such a list again.
+    def parse_html_headers(content)
+      sections = []
+      stack = []
+      content.scan(HTML_HEADER_REGEXP).each do |level,attrs,title|
+        next if attrs.nil?
+        id_attr = attrs.scan(HTML_ATTR_REGEXP).find {|name,sep,value| name == 'id'}
+        next if id_attr.nil?
+        id = id_attr[2]
+
+        section = [level.to_i, id, title, []]
+        success = false
+        while !success
+          if stack.empty?
+            sections << section
+            stack << section
+            success = true
+          elsif stack.last.first < section.first
+            stack.last.last << section
+            stack << section
+            success = true
+          else
+            stack.pop
+          end
+        end
+      end
+      sections
+    end
+
+    # Create nested fragment nodes under +parent+ from +sections+ (which can be created using
+    # +parse_html_headers+). +path+ is the source path that defines the fragments. The meta
+    # information +in_menu+ of the fragment nodes is set to the parameter +in_menu+ and the meta
+    # info +sort_info+ is calculated from the base +si+ value.
+    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)
+        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
+
+  end
+
+end

data/lib/webgen/sourcehandler/metainfo.rb

@@ -0,0 +1,117 @@
+require 'pathname'
+require 'yaml'
+require 'webgen/sourcehandler/base'
+require 'webgen/websiteaccess'
+
+module Webgen::SourceHandler
+
+  # Handles meta information files which provide meta information for other files.
+  class Metainfo
+
+    include Base
+    include Webgen::WebsiteAccess
+
+    CKEY = [:metainfo, :nodes]
+
+    # Upon creation the object registers itself as listener for some node hooks.
+    def initialize
+      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))
+      self.nodes ||= Set.new
+    end
+
+    # Create a meta info node from +parent+ and +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      super(parent, path) do |node|
+        [[:mi_paths, 'paths'], [:mi_alcn, 'alcn']].each do |mi_key, block_name|
+          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]] = {
+          :mi_paths => node.node_info[:mi_paths],
+          :mi_alcn => node.node_info[:mi_alcn]
+        }
+
+        mark_all_matched_dirty(node)
+
+        self.nodes << node
+        self.nodes = self.nodes.sort_by {|n| n.absolute_lcn}
+      end
+    end
+
+    def nodes #:nodoc:
+      website.cache.permanent[CKEY]
+    end
+
+    def nodes=(val) #:nodoc:
+      website.cache.permanent[CKEY] = val
+    end
+
+    #######
+    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, use_cache = true)
+      node.tree.node_access[:alcn].each do |path, n|
+        n.dirty_meta_info = true if meta_info_changed?(node, n, use_cache)
+      end
+    end
+
+    # Update the meta info of matched path before a node is created.
+    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
+        end
+      end
+    end
+
+    # Update the meta information of a matched alcn after the node has been created.
+    def after_node_created(node)
+      self.nodes.each do |n|
+        n.node_info[:mi_alcn].each do |pattern, mi|
+          node.meta_info.update(mi) if node =~ pattern
+        end
+      end
+    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_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
+          return
+        end
+      end
+    end
+
+    # 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])
+      self.nodes.delete(node)
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/page.rb

@@ -0,0 +1,77 @@
+require 'webgen/websiteaccess'
+require 'webgen/sourcehandler/base'
+
+module Webgen::SourceHandler
+
+  # Source handler for handling content files in Webgen Page Format.
+  class Page
+
+    include Webgen::WebsiteAccess
+    include Base
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_meta_info_changed?, method(:meta_info_changed?))
+    end
+
+    # Create a page file from +parent+ and +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      path.meta_info['lang'] ||= website.config['website.lang']
+      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[: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
+
+    # Render the block called +block_name+ of the given +node+. The parameter +templates+ is set to
+    # the default template chain for the given +node+ but you can assign a custom template chain (an
+    # array of template nodes) if need arises. Return +nil+ if an error occurred.
+    def render_node(node, block_name = 'content', templates = website.blackboard.invoke(:templates_for_node, node))
+      chain = [templates, node].flatten
+
+      if chain.first.node_info[:page].blocks.has_key?(block_name)
+        node.node_info[:used_nodes] << chain.first.absolute_lcn
+        context = chain.first.node_info[:page].blocks[block_name].render(Webgen::ContentProcessor::Context.new(:chain => chain))
+        context.content
+      else
+        raise "Error rendering <#{node.absolute_lcn}>: no block named '#{block_name}' in <#{chain.first.absolute_lcn}>"
+      end
+    end
+    alias_method :content, :render_node
+
+    #######
+    private
+    #######
+
+    # 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
+    end
+
+  end
+
+end