webgen 0.4.7 → 0.5.0

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

@@ -0,0 +1,66 @@
+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+). 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, in_menu, si = 1000 )
+      sections.each do |level, id, title, sub_sections|
+        node = website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
+                                         Webgen::Path.new('#' + id), self).first
+        node['title'] = title
+        node['in_menu'] = in_menu
+        node['sort_info'] = si = si.succ
+        node.node_info[:src] = parent.node_info[:src]
+        create_fragment_nodes(sub_sections, node, in_menu, si.succ)
+      end
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/metainfo.rb

@@ -0,0 +1,107 @@
+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_changed?, method(:node_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 = File.expand_path(key =~ /^\// ? key : File.join(parent.absolute_lcn, key))
+            node.node_info[mi_key][key.chomp('/')] = value
+          end if page.blocks.has_key?(block_name)
+        end
+
+        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
+    #######
+
+    # 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)
+      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 }
+      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_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
+          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)
+      self.nodes.delete(node)
+    end
+
+  end
+
+end

data/lib/webgen/sourcehandler/page.rb

@@ -0,0 +1,47 @@
+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
+
+    # 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[:page] = page
+        tmp_logger = website.logger
+        website.logger = nil    # disabling logging whiling creating fragment nodes
+        website.blackboard.invoke(:create_fragment_nodes,
+                                  website.blackboard.invoke(:parse_html_headers, render_node(node, 'content', [])),
+                                  node, 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
+
+  end
+
+end

data/lib/webgen/sourcehandler/template.rb

@@ -0,0 +1,64 @@
+require 'webgen/websiteaccess'
+require 'webgen/loggable'
+require 'webgen/sourcehandler/base'
+
+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 = cached_template[lang] = default_template(node.parent, lang)
+      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,72 @@
+require 'yaml'
+require 'webgen/sourcehandler/base'
+require 'webgen/websiteaccess'
+
+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
+
+    # Create all virtual nodes under +parent+ which are specified in +path+.
+    def create_node(parent, path)
+      page = page_from_path(path)
+      nodes = []
+      YAML::load(page.blocks['content'].content).each do |key, value|
+        key = (key =~ /^\// ? key : File.join(parent.absolute_lcn, key))
+        temp_parent = create_directories(parent.tree.root, File.dirname(key), path)
+
+        temp_path = Webgen::Path.new(key)
+        temp_path.meta_info.update(value || {})
+        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))
+
+        if key =~ /\/$/
+          nodes << create_directory(temp_parent, key, path, temp_path.meta_info)
+        else
+          nodes << super(temp_parent, temp_path, output_path) {|n| n.node_info[:src] = path.path}
+        end
+      end if page.blocks.has_key?('content')
+      nodes.compact
+    end
+
+    #######
+    private
+    #######
+
+    # 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, '/')),
+                                dir_handler) do |par, temp_path|
+        node = nil
+        if (node = dir_handler.node_exists?(par, temp_path)) && (!meta_info || node.node_info[:src] != path.path)
+          parent, node = node, nil
+        else
+          temp_path.meta_info.update(meta_info) if meta_info
+          parent = node = dir_handler.create_node(par, temp_path)
+          parent.node_info[:src] = path.path
+        end
+        node
+      end
+      parent
+    end
+
+  end
+
+end

data/lib/webgen/tag.rb

@@ -0,0 +1,16 @@
+module Webgen
+
+  # Namespace for all classes that are useable by Webgen::ContentProcessor::Tag.
+  #
+  # Have a look at the documentation for Webgen::Tag::Base for details on how to implement a tag
+  # class.
+  module Tag
+
+    autoload :Base, 'webgen/tag/base'
+    autoload :Relocatable, 'webgen/tag/relocatable'
+    autoload :Metainfo, 'webgen/tag/metainfo'
+    autoload :Menu, 'webgen/tag/menu'
+
+  end
+
+end