thewoolleyman-webgen 0.5.8.20090419

data/lib/webgen/sourcehandler/memory.rb

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+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

@@ -0,0 +1,128 @@
+# -*- encoding: utf-8 -*-
+
+require 'pathname'
+require 'yaml'
+
+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 ||= []
+    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] = {}
+          if page.blocks.has_key?(block_name) && (data = YAML::load(page.blocks[block_name].content))
+            data.each do |key, value|
+              key = Webgen::Common.absolute_path(key, parent.absolute_lcn)
+              node.node_info[mi_key][key] = value
+            end
+          end
+        end
+
+        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]
+        }
+
+        self.nodes << node unless self.nodes.include?(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, 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 || (option == :no_old_data && cached &&
+               ((cached[:mi_paths].keys - mi_node.node_info[:mi_paths].keys).any? do |p|
+                 Webgen::Path.match(node.node_info[:creation_path], p)
+                end || (cached[:mi_alcn].keys - mi_node.node_info[:mi_alcn].keys).any? do |p|
+                  node =~ p
+                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, option = nil)
+      node.tree.node_access[:alcn].each do |path, n|
+        n.flag(:dirty_meta_info) if meta_info_changed?(node, n, option)
+      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 Webgen::Path.match(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)
+      self.nodes.each do |n|
+        if n.flagged(:created) && meta_info_changed?(n, node)
+          node.flag(:dirty_meta_info)
+          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, :force)
+      website.cache.permanent.delete([:sh_metainfo_node_mi, node.absolute_lcn])
+      self.nodes.delete(node)
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/page.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+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|
+        node.node_info[:sh_page_node_mi] = Webgen::Page.meta_info_from_data(path.io.data)
+        node.node_info[:page] = page
+      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)
+      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
+
+end

data/lib/webgen/sourcehandler/sitemap.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+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

@@ -0,0 +1,66 @@
+# -*- encoding: utf-8 -*-
+
+module Webgen::SourceHandler
+
+  # Source handler for handling template files in Webgen Page Format.
+  class Template
+
+    include Webgen::WebsiteAccess
+    include Webgen::Loggable
+    include Base
+
+    # Create a template node in +parent+ for +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      super(parent, path) do |node|
+        node.node_info[:page] = page
+      end
+    end
+
+    # Return the template chain for +node+.
+    def templates_for_node(node, lang = node.lang)
+      cached_template = (website.cache.volatile[[node.absolute_lcn, :templates]] ||= {})
+      if cached_template[lang]
+        template_node = cached_template[lang]
+      elsif node['template'].kind_of?(String)
+        template_node = node.resolve(node['template'], lang)
+        if template_node.nil?
+          log(:warn) { "Specified template '#{node['template']}' for <#{node.absolute_lcn}> not found, using default template!" }
+          template_node = default_template(node.parent, lang)
+        end
+        cached_template[lang] = template_node
+      elsif node.meta_info.has_key?('template') && node['template'].nil?
+        template_node = cached_template[lang] = nil
+      else
+        log(:info) { "Using default template in language '#{lang}' for <#{node.absolute_lcn}>" }
+        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?
+        []
+      else
+        (template_node == node ? [] : templates_for_node(template_node, lang) + [template_node])
+      end
+    end
+
+    # Return the default template for the directory node +dir+. If the template node is not found,
+    # the parent directories are searched.
+    def default_template(dir_node, lang)
+      template_node = dir_node.resolve(website.config['sourcehandler.template.default_template'], lang)
+      if template_node.nil?
+        if dir_node.is_root?
+          log(:warn) { "No default template in root directory found!" }
+        else
+          template_node = default_template(dir_node.parent, lang)
+        end
+      end
+      template_node
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/virtual.rb

@@ -0,0 +1,110 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri'
+require 'yaml'
+
+module Webgen::SourceHandler
+
+  # Handles files which contain specifications for "virtual" nodes, ie. nodes that don't have real
+  # source path.
+  #
+  # This can be used, for example, to provide multiple links to the same node.
+  class Virtual
+
+    include Base
+    include Webgen::WebsiteAccess
+
+    def initialize # :nodoc:
+      website.blackboard.add_listener(:node_meta_info_changed?, method(:node_meta_info_changed?))
+      @path_data = {}
+    end
+
+    # Create all virtual nodes under +parent+ which are specified in +path+.
+    def create_node(parent, path)
+      nodes = []
+      read_data(path).each do |key, meta_info|
+        cache_data = [key, meta_info.dup]
+
+        key = Webgen::Common.absolute_path(key, parent.absolute_lcn) + (key =~ /\/$/ ? '/' : '')
+        temp_parent = create_directories(parent.tree.root, File.dirname(key), path)
+
+        output_path = meta_info.delete('url') || key
+        output_path = (URI::parse(output_path).absolute? || output_path =~ /^\// ?
+                       output_path : File.join(temp_parent.absolute_lcn, output_path))
+
+        if key =~ /\/$/
+          nodes << create_directory(temp_parent, key, path, meta_info)
+        else
+          nodes += website.blackboard.invoke(:create_nodes, parent.tree, temp_parent.absolute_lcn,
+                                             Webgen::Path.new(key, path.source_path), self) do |cn_parent, cn_path|
+            cn_path.meta_info.update(meta_info)
+            super(cn_parent, cn_path, output_path) do |n|
+              n.node_info[:sh_virtual_cache_data] = cache_data
+            end
+          end
+        end
+      end
+      nodes.compact
+    end
+
+    #######
+    private
+    #######
+
+    # Read the entries from the virtual file +data+ and yield the path, and the meta info hash for
+    # each entry. The +parent+ parameter is used for making absolute path values if relative ones
+    # are given.
+    def read_data(path)
+      if !@path_data.has_key?(path) || path.changed?
+        page = page_from_path(path)
+        @path_data[path] = YAML::load(page.blocks['content'].content).collect do |key, meta_info|
+          meta_info ||= {}
+          meta_info['modified_at'] = path.meta_info['modified_at']
+          meta_info['no_output'] = true
+          [key, meta_info]
+        end if page.blocks.has_key?('content')
+        @path_data[path] ||= []
+      end
+      @path_data[path]
+    end
+
+    # Create the needed parent directories for a virtual node.
+    def create_directories(parent, dirname, path)
+      dirname.sub(/^\//, '').split('/').each do |dir|
+        parent = create_directory(parent, File.join(parent.absolute_lcn, dir), path)
+      end
+      parent
+    end
+
+    # Create a virtual directory if it does not already exist.
+    def create_directory(parent, dir, path, meta_info = nil)
+      dir_handler = website.cache.instance('Webgen::SourceHandler::Directory')
+      website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
+                                Webgen::Path.new(File.join(dir, '/'), path.source_path),
+                                dir_handler) do |par, temp_path|
+        parent = dir_handler.node_exists?(par, temp_path)
+        if (parent && (parent.node_info[:src] == path.source_path) && !meta_info.nil?) ||
+            !parent
+          temp_path.meta_info.update(meta_info) if meta_info
+          parent.flag(:reinit) if parent
+          parent = dir_handler.create_node(par, temp_path)
+        end
+        parent
+      end
+      parent
+    end
+
+    # Check if the +node+ is virtual and if, if its meta information has changed. This can only be
+    # the case if the node has been recreated in this run.
+    def node_meta_info_changed?(node)
+      path = website.blackboard.invoke(:source_paths)[node.node_info[:src]]
+      return if node.node_info[:processor] != self.class.name || !path.changed?
+
+      old_data = node.node_info[:sh_virtual_cache_data]
+      new_data = read_data(path).find {|key, mi| key == old_data.first}
+      node.flag(:dirty_meta_info) if !new_data || old_data.last != new_data.last
+    end
+
+  end
+
+end