webgen 1.0.0.beta1 → 1.0.0.beta2

data/lib/webgen/path_handler/feed.rb

@@ -23,6 +23,34 @@ module Webgen
       include Base
       include PageUtils
 
+
+      # Provides custom methods needed for feed nodes.
+      class Node < PageUtils::Node
+
+        # Return the entries for this feed node.
+        def feed_entries
+          tree.website.ext.node_finder.find(self['entries'], self)
+        end
+
+        # Return the feed link URL for this feed node.
+        def feed_link
+          Webgen::Path.url(File.join(self['site_url'], tree[self['link']].dest_path), false)
+        end
+
+        # Return the content of an +entry+ (a Node object) of this feed node.
+        def entry_content(entry)
+          block_name = self['content_block_name'] || 'content'
+          if entry.respond_to?(:render_block) && entry.blocks[block_name]
+            entry.render_block(block_name, Webgen::Context.new(tree.website, :chain => [entry])).content
+          else
+            tree.website.logger.warn { "Feed entry <#{entry}> not used, is not a renderable node" }
+            ''
+          end
+        end
+
+      end
+
+
       # The mandatory keys that need to be set in a feed file.
       MANDATORY_INFOS = %W[site_url author entries]
 
@@ -40,7 +68,7 @@ module Webgen
         path.ext = path['version']
         path['dest_path'] = '<parent><basename>(.<lang>)<ext>'
         path['cn'] = '<basename><ext>'
-        create_node(path) do |node|
+        create_node(path, Node) do |node|
           set_blocks(node, blocks)
           node.meta_info['link'] ||= node.parent.alcn
           @website.ext.item_tracker.add(node, :nodes, :node_finder_option_set,
@@ -55,27 +83,6 @@ module Webgen
                              :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

data/lib/webgen/path_handler/page.rb

@@ -25,10 +25,8 @@ module Webgen
       #
       # 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)
+      def content(node, block_name = 'content', chain = node.template_chain)
         chain << node
-
         chain.first.render_block(block_name, Webgen::Context.new(@website, :chain => chain)).content
       end
 

data/lib/webgen/path_handler/page_utils.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-require 'webgen/path_handler'
+require 'webgen/path_handler/base'
 require 'webgen/page'
 require 'webgen/error'
 
@@ -14,6 +14,119 @@ module Webgen
     # to override this method if you need custom behaviour!
     module PageUtils
 
+      # Custom Node class that provides easy access to the blocks of the parsed page file and
+      # methods for rendering a block.
+      class Node < Webgen::PathHandler::Base::Node
+
+        # Return the blocks (see PageUtils#parse_as_page!) for this node.
+        def blocks
+          node_info[:blocks]
+        end
+
+        # Render the block +name+ of this 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(name, context, pipeline = nil)
+          unless blocks.has_key?(name)
+            raise Webgen::RenderError.new("No block named '#{name}' found", nil, context.dest_node.alcn, alcn)
+          end
+
+          content_processor = context.website.ext.content_processor
+          context.website.ext.item_tracker.add(context.dest_node, :node_content, alcn)
+
+          context.content = blocks[name].dup
+          context[:block_name] = name
+          pipeline ||= ((self['blocks'] || {})[name] || {})['pipeline'] ||
+            ((self['blocks'] || {})['defaults'] || {})['pipeline'] ||
+            []
+          content_processor.normalize_pipeline(pipeline).each do |processor|
+            content_processor.call(processor, context)
+          end
+          context[:block_name] = nil
+          context
+        end
+
+        # Return the template chain for this 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(lang = @lang)
+          cached_template = (tree.website.cache.volatile[[alcn, :templates]] ||= {})
+          if cached_template.has_key?(lang)
+            template_node = cached_template[lang]
+          elsif self['template'].kind_of?(String)
+            template_node = resolve(self['template'], lang, true)
+            if template_node.nil?
+              tree.website.logger.warn do
+                ["Template '#{self['template']}' for <#{self}> not found, using default template!",
+                 'Fix the value of the meta information \'template\' for <#{self}>']
+              end
+              template_node = default_template(parent, lang)
+            end
+            cached_template[lang] = template_node
+          elsif meta_info.has_key?('template') && self['template'].nil?
+            template_node = cached_template[lang] = nil
+          else
+            tree.website.logger.debug { "Using default template in language '#{lang}' for <#{self}>" }
+            template_node = default_template(parent, lang)
+            if template_node == self && !parent.is_root?
+              template_node = default_template(parent.parent, lang)
+            end
+            cached_template[lang] = template_node
+          end
+
+          if template_node.nil?
+            []
+          else
+            (template_node == self ? [] : template_node.template_chain(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 = tree.website.config['path_handler.default_template']
+          template = dir.resolve(default_template_name, lang)
+          if template.nil?
+            if dir.is_root?
+              tree.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
+        protected :default_template
+
+      end
+
+
+      def create_node(path, node_klass = Node) #:nodoc:
+        super
+      end
+
       # 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)
@@ -41,38 +154,6 @@ module Webgen
       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

data/lib/webgen/path_handler/sitemap.rb

@@ -15,6 +15,18 @@ module Webgen
       include Base
       include PageUtils
 
+
+      # Provides custom methods for sitemap nodes.
+      class Node < PageUtils::Node
+
+        # Return the entries for the sitemap +node+.
+        def sitemap_entries
+          tree.website.ext.node_finder.find(node_info[:entries], self)
+        end
+
+      end
+
+
       # The mandatory keys that need to be set in a sitemap file.
       MANDATORY_INFOS = %W[site_url entries]
 
@@ -26,7 +38,7 @@ module Webgen
         end
 
         path.ext = 'xml'
-        create_node(path) do |node|
+        create_node(path, Node) 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,
@@ -41,11 +53,6 @@ module Webgen
                              :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

data/lib/webgen/path_handler/template.rb

@@ -20,76 +20,6 @@ module Webgen
         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

data/lib/webgen/path_handler/virtual.rb

@@ -60,8 +60,16 @@ module Webgen
       # each entry.
       def read_entries(blocks)
         blocks.each do |name, content|
-          YAML::load(content).each do |key, meta_info|
-            yield(key, meta_info || {})
+          begin
+            data = YAML::load(content)
+          rescue RuntimeError, ArgumentError, SyntaxError => e
+            raise RuntimeError, "Problem parsing block '#{name}' (it needs to contain a YAML hash): #{e.message}", e.backtrace
+          end
+          raise "Structure of block '#{name}' is invalid, it has to be a Hash" unless data.kind_of?(Hash)
+          data.each do |key, meta_info|
+            meta_info ||= {}
+            raise "Each path key value needs to be a Hash, found a #{meta_info.class} for '#{key}'" unless meta_info.kind_of?(Hash)
+            yield(key, meta_info)
           end
         end
       end

data/lib/webgen/tag.rb

@@ -42,7 +42,7 @@ module Webgen
   #
   # webgen tags allow the specification of options in the tag definition. When registering a tag,
   # one can specify which options are mandatory, i.e. which options always have to be set directly
-  # for the tag. The value of the option :config_base for the #register method is used to resolve
+  # for the tag. The value of the option :config_prefix for the #register method is used to resolve
   # partially stated configuration entries.
   #
   # == Sample Tag
@@ -111,10 +111,10 @@ module Webgen
     #          The name :default is used for specifying the default tag which is called if an
     #          unknown tag name is encountered.
     #
-    # [:config_base] The configuration base, i.e. the part of a configuration option name that does
-    #                not need to be specified. Defaults to the full class name without the Webgen
-    #                module downcased and all "::" substituted with "." (e.g. Webgen::Tag::Menu →
-    #                tag.menu). Needs to be specified when a block is used!
+    # [:config_prefix] The configuration prefix, i.e. the part of a configuration option name that
+    #                  does not need to be specified. Defaults to the full class name without the
+    #                  Webgen module downcased and all "::" substituted with "." (e.g.
+    #                  Webgen::Tag::Menu → tag.menu). Needs to be specified when a block is used!
     #
     # [:mandatory] A list of configuration option names whose values always need to be provided. The
     #              first configuration option name is used as the default mandatory option (used
@@ -128,20 +128,20 @@ module Webgen
     #
     #   tag.register('MyModule::Date', names: ['mydate', 'date'])
     #
-    #   tag.register('date', config_base: 'tag.date') do |tag, body, context|
+    #   tag.register('date', config_prefix: 'tag.date') do |tag, body, context|
     #     Time.now.strftime(param('tag.date.format'))
     #   end
     #
     def register(klass, options = {}, &block)
-      if block_given? && !options[:config_base]
-        raise ArgumentError, "The option :config_base needs to be specified when using a block"
+      if block_given? && !options[:config_prefix]
+        raise ArgumentError, "The option :config_prefix needs to be specified when registering a tag using a block"
       end
 
       names = [options.delete(:names)].flatten.compact
       options[:name] = names.shift
       name = do_register(klass, options, true, &block)
       ext_data(name).mandatory = options[:mandatory] || []
-      ext_data(name).config_base = options[:config_base] ||
+      ext_data(name).config_prefix = options[:config_prefix] ||
         Webgen::Utils.snake_case(ext_data(name).object.to_s.gsub(/::/, '.').gsub(/^Webgen\./, ''))
       ext_data(name).initialized = false
       names.each {|n| @extensions[n.to_sym] = @extensions[name]}
@@ -182,7 +182,7 @@ module Webgen
     #######
 
     # Create the Webgen::Configuration object from the parameters and the given configuration
-    # base.
+    # prefix.
     def create_config(tag, params, tdata, context)
       values = case params
                when Hash then values_from_hash(tag, params, tdata, context)
@@ -208,8 +208,8 @@ module Webgen
       params.each do |key, value|
         if context.website.config.option?(key)
           result[key] = value
-        elsif context.website.config.option?(tdata.config_base + '.' + key)
-          result[tdata.config_base + '.' + key] = value
+        elsif context.website.config.option?(tdata.config_prefix + '.' + key)
+          result[tdata.config_prefix + '.' + key] = value
         else
           context.website.logger.warn do
             ["Invalid configuration option '#{key}' for tag '#{tag}' found in <#{context.ref_node}>",
@@ -241,7 +241,7 @@ module Webgen
         tdata.object = resolve_class(tdata.object)
         tdata.mandatory.each_with_index do |o, index|
           next if context.website.config.option?(o)
-          o = tdata.config_base + '.' + o
+          o = tdata.config_prefix + '.' + o
           if context.website.config.option?(o)
             tdata.mandatory[index] = o
           else