webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/path_handler/copy.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/path_handler/base'
+require 'webgen/context'
+
+module Webgen
+  class PathHandler
+
+    # Simple path handler for copying files from the source to the destination, either without
+    # changing anything or by applying one or more content processors.
+    class Copy
+
+      include Base
+
+      # Create the node for +path+.
+      #
+      # The following order is used for finding the (optional) content processor pipeline:
+      #
+      # * If the pipeline meta info key is specified, it is used.
+      #
+      # * If the +path+ has the names of content processors as parts in the file extension, all
+      #   extension parts until the first non-content processor part will be used for the pipeline
+      #   and removed from the extension.
+      #
+      #   If the last extension part is a file extension registered with a content processor (using
+      #   the :ext_map facility), the corresponding content processor is appended to the pipeline
+      #   and the post-process file extension name is used.
+      #
+      # Here are some examples:
+      #
+      # * pipeline = ['erb'] → only erb is used, extension is not modified
+      #
+      # * path = 'test.erb.kramdown.html', no pipeline → pipeline is set to ['erb', 'kramdown'] and
+      #   path extension is changed to '.html', ie. path = 'test.html'
+      #
+      # * path = 'test.erb.kramdown.unknown.html', no pipeline → pipeline is set ['erb', 'kramdown']
+      #   and path extension is changed to 'unknown.html', ie. path = 'test.unknown.html'
+      #
+      # * path = 'test.erb.sass', no pipeline → pipeline is set to ['erb', 'sass'] and path
+      #   extension is changed to '.css', ie. path = 'test.css'
+      #
+      # * path = 'test.sass', no pipeline → pipeline is set to ['sass'] and path extension is
+      #   changed to '.css', ie. path = 'test.css'
+      def create_nodes(path)
+        if !path.meta_info.has_key?('pipeline')
+          pipeline = []
+          exts = path.ext.split('.')
+          pipeline << exts.shift while exts.length > 1 && @website.ext.content_processor.registered?(exts.first)
+          if (data = @website.ext.content_processor.map_extension(exts.last))
+            pipeline << data.first
+            exts[-1] = data.last
+          end
+          path.meta_info['pipeline'] = pipeline unless pipeline.empty?
+          path.ext = exts.join('.')
+        end
+
+        create_node(path)
+      end
+
+      # Return the processed content of the +node+ if the pipeline meta info key is specified or the
+      # IO object for the node's source path.
+      def content(node)
+        if pipeline = node.meta_info['pipeline']
+          pipeline = @website.ext.content_processor.normalize_pipeline(pipeline)
+          is_binary = @website.ext.content_processor.is_binary?(pipeline.first)
+          context = Webgen::Context.new(@website, :chain => [node],
+                                        :content => node.node_info[:path].data(is_binary ? 'rb' : 'r'))
+          pipeline.each {|processor| @website.ext.content_processor.call(processor, context)}
+          context.content
+        else
+          node.node_info[:path]
+        end
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/directory.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/path_handler/base'
+
+module Webgen
+  class PathHandler
+
+    # Path handler for directory source paths. Has nothing special to do.
+    class Directory
+
+      include Base
+
+      # Create the node for +path+.
+      def create_nodes(path)
+        create_node(path)
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/feed.rb

@@ -0,0 +1,82 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/path_handler/base'
+require 'webgen/path_handler/page_utils'
+require 'webgen/context'
+require 'webgen/path'
+require 'time'
+
+module Webgen
+  class PathHandler
+
+    # Path handler for creating atom and/or rss feeds.
+    #
+    # When customizing a feed template one can use the following utiltity methods:
+    #
+    # * #feed_entries
+    # * #feed_link
+    # * #entry_content
+    #
+    # Have a look at the default feed templates to see them in action.
+    class Feed
+
+      include Base
+      include PageUtils
+
+      # The mandatory keys that need to be set in a feed file.
+      MANDATORY_INFOS = %W[site_url author entries]
+
+      # Create the feed nodes.
+      def create_nodes(path, blocks)
+        if MANDATORY_INFOS.any? {|t| path.meta_info[t].nil?}
+          raise Webgen::NodeCreationError.new("At least one of #{MANDATORY_INFOS.join('/')} is missing",
+                                              self.class.name, path)
+        end
+        if !['atom', 'rss'].include?(path['version'])
+          raise Webgen::NodeCreationError.new("Invalid version '#{path['version']}' for feed path specified, only atom and rss allowed",
+                                              self.class.name, path)
+        end
+
+        path.ext = path['version']
+        path['dest_path'] = '<parent><basename>(.<lang>)<ext>'
+        path['cn'] = '<basename><ext>'
+        create_node(path) do |node|
+          set_blocks(node, blocks)
+          node.meta_info['link'] ||= node.parent.alcn
+          @website.ext.item_tracker.add(node, :nodes, :node_finder_option_set,
+                                        {:opts => node['entries'], :ref_alcn => node.alcn}, :content)
+        end
+      end
+
+      # Return the rendered feed represented by +node+.
+      def content(node)
+        context = Webgen::Context.new(@website)
+        context.render_block(:name => "#{node['version']}_template", :node => 'first',
+                             :chain => [node, node.resolve("/templates/feed.template", node.lang, true), node].compact)
+      end
+
+      # Return the entries for the feed node.
+      def feed_entries(node)
+        @website.ext.node_finder.find(node['entries'], node)
+      end
+
+      # Return the feed link URL for the feed node.
+      def feed_link(node)
+        Webgen::Path.url(File.join(node['site_url'], node.tree[node['link']].dest_path), false)
+      end
+
+      # Return the content of an +entry+ of the feed +node+.
+      def entry_content(node, entry)
+        block_name = node['content_block_name'] || 'content'
+        if entry.respond_to?(:render_block) && entry.blocks[block_name]
+          entry.render_block(block_name, Webgen::Context.new(@website, :chain => [entry])).content
+        else
+          @website.logger.warn { "Feed entry <#{entry}> not used, is not a renderable node" }
+          ''
+        end
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/meta_info.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+
+require 'pathname'
+require 'set'
+require 'yaml'
+require 'webgen/path_handler/base'
+require 'webgen/path_handler/page_utils'
+
+module Webgen
+  class PathHandler
+
+    # Handles meta information paths which provide meta information for other paths.
+    class MetaInfo
+
+      include Base
+      include PageUtils
+
+      # Upon creation the path handler registers itself as listener for the :apply_meta_info_to_path and
+      # :after_node_created hooks so that it can apply the meta information.
+      def initialize(website)
+        super
+        @website.blackboard.add_listener(:apply_meta_info_to_path, &method(:apply_meta_info_to_path))
+        @website.blackboard.add_listener(:after_node_created, &method(:after_node_created))
+        @paths = []
+        @alcns = []
+      end
+
+      # Create a meta info node from +path+.
+      def create_nodes(path, blocks)
+        @paths += add_data(path, blocks['paths'], 'paths')
+        entries = add_data(path, blocks['alcn'], 'alcn')
+        @alcns += entries
+        update_existing_nodes(entries)
+
+        nil
+      end
+
+      #######
+      private
+      #######
+
+      # Add the data from the given page block to the hash.
+      def add_data(path, content, block_name)
+        entries = []
+        if content && (data = YAML::load(content))
+          data.each do |(*keys), value|
+            value = Marshal.dump(value)
+            keys.each {|key| entries << [Webgen::Path.append(path.parent_path, key), value]}
+          end
+        end
+        entries
+      rescue Exception => e
+        raise Webgen::NodeCreationError.new("Could not parse block '#{block_name}': #{e.message}", self.class.name)
+      end
+
+      # Update already existing nodes with meta information from the given meta info node.
+      def update_existing_nodes(entries)
+        @website.tree.node_access[:alcn].each do |alcn, node|
+          entries.each do |pattern, mi|
+            node.meta_info.update(Marshal.load(mi)) if Webgen::Path.matches_pattern?(alcn, pattern)
+          end
+        end
+      end
+
+      # Update the meta info of matched path before a node is created.
+      def apply_meta_info_to_path(path)
+        hash = {}
+        @paths.each do |pattern, mi|
+          hash.merge!(Marshal.load(mi)) if Webgen::Path.matches_pattern?(path, pattern)
+        end
+        path.meta_info.replace(hash.merge!(path.meta_info)) if hash.length > 0
+      end
+
+      # Update the meta information of a matched alcn after the node has been created.
+      def after_node_created(node)
+        @alcns.each do |pattern, mi|
+          node.meta_info.update(Marshal.load(mi)) if Webgen::Path.matches_pattern?(node.alcn, pattern)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/page.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/path_handler/base'
+require 'webgen/path_handler/page_utils'
+
+module Webgen
+  class PathHandler
+
+    # Path handler for handling content files in Webgen Page Format.
+    class Page
+
+      include Base
+      include PageUtils
+
+      # Create a page file from +path+.
+      def create_nodes(path, blocks)
+        path.meta_info['lang'] ||= @website.config['website.lang']
+        path.ext = 'html' if path.ext == 'page'
+        create_node(path) do |node|
+          set_blocks(node, blocks)
+        end
+      end
+
+      # Render the block +block_name+ of the given +node+.
+      #
+      # If the parameter +chain+ (an array of template nodes) is not set, the default template chain
+      # for the given +node+ is used.
+      def content(node, block_name = 'content', chain = nil)
+        chain ||= @website.ext.path_handler.instance(:template).template_chain(node)
+        chain << node
+
+        chain.first.render_block(block_name, Webgen::Context.new(@website, :chain => chain)).content
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/page_utils.rb

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/path_handler'
+require 'webgen/page'
+require 'webgen/error'
+
+module Webgen
+  class PathHandler
+
+    # This module should be used by path handlers that need to work with paths in Webgen Page Format.
+    #
+    # Note that this modules provides an implementation for the #parse_meta_info! method. If you
+    # also include the Base module, make sure that you include it before this module! Also make sure
+    # to override this method if you need custom behaviour!
+    module PageUtils
+
+      # Calls #parse_as_page! to update the meta information hash of +path+. Returns the found
+      # blocks which will be passed as second parameter to the #create_nodes method.
+      def parse_meta_info!(path)
+        parse_as_page!(path)
+      end
+
+      # Assume that the content of the given +path+ is in Webgen Page Format and parse it. Updates
+      # 'path.meta_info' with the meta info from the page and returns the content blocks.
+      def parse_as_page!(path)
+        begin
+          page = Webgen::Page.from_data(path.data)
+        rescue Webgen::Page::FormatError => e
+          raise Webgen::Error.new("Error reading source path: #{e.message}", self.class.name, path)
+        end
+        blocks = page.meta_info.delete('blocks') || {}
+        path.meta_info.merge!(page.meta_info)
+        blocks.each {|key, val| ((path.meta_info['blocks'] ||= {})[key] ||= {}).merge!(val)}
+        page.blocks
+      end
+      private :parse_as_page!
+
+      # Set the blocks (see #parse_as_page!) for the node.
+      def set_blocks(node, blocks)
+        node.node_info[:blocks] = blocks
+      end
+      private :set_blocks
+
+      # Return the blocks (see #parse_as_page!) for the node.
+      def blocks(node)
+        node.node_info[:blocks]
+      end
+
+      # Render the block +name+ of +node+ using the provided Context object.
+      #
+      # Uses the content processors specified for the block via the +blocks+ meta information key if
+      # the +pipeline+ parameter is not set.
+      #
+      # Returns the given context with the rendered content.
+      def render_block(node, name, context, pipeline = nil)
+        unless node.blocks.has_key?(name)
+          raise Webgen::RenderError.new("No block named '#{name}' found", self.class.name,
+                                        context.dest_node.alcn, node.alcn)
+        end
+
+        content_processor = context.website.ext.content_processor
+        context.website.ext.item_tracker.add(context.dest_node, :node_content, node.alcn)
+
+        context.content = node.blocks[name].dup
+        context[:block_name] = name
+        pipeline ||= ((node.meta_info['blocks'] || {})[name] || {})['pipeline'] ||
+          ((node.meta_info['blocks'] || {})['defaults'] || {})['pipeline'] ||
+          []
+        content_processor.normalize_pipeline(pipeline).each do |processor|
+          content_processor.call(processor, context)
+        end
+        context[:block_name] = nil
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/sitemap.rb

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+require 'uri'
+require 'time'
+require 'webgen/path_handler/base'
+require 'webgen/path_handler/page_utils'
+require 'webgen/context'
+
+module Webgen
+  class PathHandler
+
+    # Path handler for creating an XML sitemap based on the specification of http://sitemaps.org.
+    class Sitemap
+
+      include Base
+      include PageUtils
+
+      # The mandatory keys that need to be set in a sitemap file.
+      MANDATORY_INFOS = %W[site_url entries]
+
+      # Create an XML sitemap from +path+.
+      def create_nodes(path, blocks)
+        if MANDATORY_INFOS.any? {|t| path.meta_info[t].nil?}
+          raise Webgen::NodeCreationError.new("At least one of #{MANDATORY_INFOS.join('/')} is missing",
+                                              self.class.name, path)
+        end
+
+        path.ext = 'xml'
+        create_node(path) do |node|
+          set_blocks(node, blocks)
+          node.node_info[:entries] = {:flatten => true, :and => node['entries']}
+          @website.ext.item_tracker.add(node, :nodes, :node_finder_option_set,
+                                        {:opts => node.node_info[:entries], :ref_alcn => node.alcn}, :meta_info)
+        end
+      end
+
+      # Return the rendered feed represented by +node+.
+      def content(node)
+        context = Webgen::Context.new(@website)
+        context.render_block(:name => "sitemap", :node => 'first',
+                             :chain => [node, node.resolve("/templates/sitemap.template", node.lang, true), node].compact)
+      end
+
+      # Return the entries for the sitemap +node+.
+      def sitemap_entries(node)
+        @website.ext.node_finder.find(node.node_info[:entries], node)
+      end
+
+    end
+
+  end
+end

data/lib/webgen/path_handler/template.rb

@@ -0,0 +1,96 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/path_handler/base'
+require 'webgen/path_handler/page_utils'
+
+module Webgen
+  class PathHandler
+
+    # Path handler for handling template files in Webgen Page Format.
+    class Template
+
+      include Base
+      include PageUtils
+
+      # Create a template node for +path+.
+      def create_nodes(path, blocks)
+        create_node(path) do |node|
+          node.meta_info['no_output'] = true
+          set_blocks(node, blocks)
+        end
+      end
+
+      # Return the template chain for +node+
+      #
+      # When invoked directly, the +lang+ parameter should not be used. This parameter is necessary
+      # for the recursive invocation of the method so that the correct templates are used. Consider
+      # the following path hierarchy:
+      #
+      #   /default.en.template
+      #   /default.de.template
+      #   /custom.template
+      #   /index.de.page                  template: custom.template
+      #   /index.en.page                  template: custom.template
+      #
+      # The template chains for index.en.page and index.de.page are therefore
+      #
+      #   /default.en.template → /custom.template
+      #   /default.de.template → /custom.template
+      #
+      # This means that the /custom.template needs to reference different templates depending on the
+      # language.
+      def template_chain(node, lang = node.lang)
+        cached_template = (@website.cache.volatile[[node.alcn, :templates]] ||= {})
+        if cached_template.has_key?(lang)
+          template_node = cached_template[lang]
+        elsif node['template'].kind_of?(String)
+          template_node = node.resolve(node['template'], lang, true)
+          if template_node.nil?
+            @website.logger.warn do
+              ["Template '#{node['template']}' for <#{node}> not found, using default template!",
+               'Fix the value of the meta information \'template\' for <#{node}>']
+            end
+            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
+          @website.logger.debug { "Using default template in language '#{lang}' for <#{node}>" }
+          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 ? [] : template_chain(template_node, lang) + [template_node])
+        end
+      end
+
+      # Return the default template for the directory node +dir+ and language +lang+.
+      #
+      # If the template node is not found, the parent directories are searched.
+      def default_template(dir, lang)
+        default_template_name = @website.config['path_handler.template.default_template']
+        template = dir.resolve(default_template_name, lang)
+        if template.nil?
+          if dir.is_root?
+            @website.logger.warn do
+              ["Default template '#{default_template_name}' not found in root directory!",
+               'Provide a </#{default_template_name}> to fix this warning.']
+            end
+          else
+            template = default_template(dir.parent, lang)
+          end
+        end
+        template
+      end
+
+    end
+
+  end
+end