webgen 0.5.8 → 0.5.9

data/lib/webgen/sourcehandler/copy.rb

@@ -9,9 +9,9 @@ module Webgen::SourceHandler
     include Webgen::WebsiteAccess
     include Base
 
-    # Create the node for +parent+ and +path+. If the +path+ has the name of a content processor as
-    # the first part in the extension, it is preprocessed.
-    def create_node(parent, path)
+    # Create the node for +path+. If the +path+ has the name of a content processor as the first
+    # part in the extension, it is preprocessed.
+    def create_node(path)
       if path.ext.index('.')
         processor, *rest = path.ext.split('.')
         if website.blackboard.invoke(:content_processor_names).include?(processor)
@@ -20,7 +20,7 @@ module Webgen::SourceHandler
           processor = nil
         end
       end
-      super(parent, path) do |node|
+      super(path) do |node|
         node.node_info[:preprocessor] = processor
       end
     end
@@ -30,7 +30,8 @@ module Webgen::SourceHandler
     def content(node)
       io = website.blackboard.invoke(:source_paths)[node.node_info[:src]].io
       if node.node_info[:preprocessor]
-        context = Webgen::Context.new(:content => io.data, :chain => [node])
+        is_binary = website.blackboard.invoke(:content_processor_binary?, node.node_info[:preprocessor])
+        context = Webgen::Context.new(:content => io.data(is_binary ? 'rb' : 'r'), :chain => [node])
         website.blackboard.invoke(:content_processor, node.node_info[:preprocessor]).call(context)
         context.content
       else

data/lib/webgen/sourcehandler/directory.rb

@@ -16,21 +16,15 @@ module Webgen::SourceHandler
     # ignored). The path +path+ is the path that lead to the creation of these directories.
     def create_directories(parent, dirname, path)
       dirname.sub(/^\//, '').split('/').each do |dir|
-        dir_path = Webgen::Path.new(File.join(parent.absolute_lcn, dir, '/'), path)
-        nodes = website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
-                                           dir_path, self) do |dir_parent, dir_path|
-          node_exists?(dir_parent, dir_path) || create_node(dir_parent, dir_path)
+        dir_path = Webgen::Path.new(File.join(parent.alcn, dir, '/'), path)
+        nodes = website.blackboard.invoke(:create_nodes, dir_path, self) do |dir_path|
+          node_exists?(dir_path) || create_node(dir_path)
         end
         parent = nodes.first
       end
       parent
     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

@@ -15,18 +15,19 @@ module Webgen::SourceHandler
       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)
+    # Create atom and/or rss feed files from +path+.
+    def create_node(path)
       page = page_from_path(path)
-      path.meta_info['link'] ||= parent.absolute_lcn
+      path.meta_info['link'] ||= path.parent_path
 
       if MANDATORY_INFOS.any? {|t| path.meta_info[t].nil?}
-        raise "One of #{MANDATORY_INFOS.join('/')} information missing for feed <#{path}>"
+        raise Webgen::NodeCreationError.new("At least one of #{MANDATORY_INFOS.join('/')} is missing",
+                                            self.class.name, path)
       end
 
       create_feed_node = lambda do |type|
         path.ext = type
-        super(parent, path) do |node|
+        super(path) do |node|
           node.node_info[:feed] = page
           node.node_info[:feed_type] = type
         end
@@ -41,74 +42,48 @@ module Webgen::SourceHandler
 
     # 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}
+      website.cache[[:sourcehandler_feed, node.node_info[:src]]] = feed_entries(node).map {|n| n.alcn}
+
       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::Context.new(:chain => [node])).content
+        node.node_info[:feed].blocks[block_name].render(Webgen::Context.new(:chain => [node])).content
       else
-        feed = (website.cache.volatile[:sourcehandler_feed] ||= {})[node.node_info[:src]] ||= build_feed_for(node)
-        feed.build_xml(node.node_info[:feed_type], (node.node_info[:feed_type] == 'rss' ? node['rss_version'] || 2.0 : nil))
+        chain = [node.resolve("/templates/#{node.node_info[:feed_type]}_feed.template"), node]
+        node.node_info[:used_nodes] << chain.first.alcn
+        chain.first.node_info[:page].blocks['content'].render(Webgen::Context.new(:chain => chain)).content
       end
     end
 
-    # Helper method for returning the entries for the feed node +node+.
+    # Return the entries for the feed +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| Webgen::Common.absolute_path(pat, node.parent.absolute_lcn)}
+      patterns = [node['entries']].flatten.map {|pat| Webgen::Path.make_absolute(node.parent.alcn, pat)}
 
       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']}[0, nr_items]
     end
 
+    # Return the feed link URL for the feed +node+.
+    def feed_link(node)
+      Webgen::Node.url(File.join(node['site_url'], node.tree[node['link']].path), false)
+    end
+
+    # Return the content of an +entry+ of the feed +node+.
+    def entry_content(node, entry)
+      entry.node_info[:page].blocks[node['content_block_name'] || 'content'].render(Webgen::Context.new(:chain => [entry])).content
+    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'
-
-      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[node['content_block_name'] || 'content'].render(Webgen::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 any of the nodes used by this feed +node+ have changed and then mark the node as
     # dirty.
     def node_changed?(node)
       return if node.node_info[:processor] != self.class.name
       entries = node.feed_entries
-      node.flag(:dirty) if entries.map {|n| n.absolute_lcn } != website.cache[[:sourcehandler_feed, node.node_info[:src]]] ||
+      node.flag(:dirty) if entries.map {|n| n.alcn } != website.cache[[:sourcehandler_feed, node.node_info[:src]]] ||
         entries.any? {|n| n.changed?}
     end
 

data/lib/webgen/sourcehandler/fragment.rb

@@ -46,18 +46,20 @@ module Webgen::SourceHandler
     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 )
+    # +parse_html_headers+). +path+ is the source path that defines the fragments (which is not the
+    # same as the creation path for +parent+). 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,
-                                         Webgen::Path.new('#' + id, path.source_path),
-                                         self) do |cn_parent, cn_path|
+        fragment_path = parent.alcn.sub(/#.*$/, '') + '#' + id
+        node = website.blackboard.invoke(:create_nodes,
+                                         Webgen::Path.new(fragment_path, path.source_path),
+                                         self) do |cn_path|
           cn_path.meta_info['title'] = title
           cn_path.meta_info['in_menu'] = in_menu
           cn_path.meta_info['sort_info'] = si = si.succ
-          create_node(cn_parent, cn_path)
+          create_node(cn_path, :parent => parent)
         end.first
         create_fragment_nodes(sub_sections, node, path, in_menu, si.succ)
       end

data/lib/webgen/sourcehandler/memory.rb

@@ -15,23 +15,22 @@ module Webgen::SourceHandler
       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|
+    # Create a node for the +path+. The +source_alcn+ specifies 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 returns a string (or a Webgen::Path::SourceIO object).
+    def create_node(path, source_alcn, data = nil)
+      super(path) do |node|
         node.node_info[:memory_source_alcn] = source_alcn
-        (@data ||= {})[node.absolute_lcn] = lambda { data || yield(node) }
+        (@data ||= {})[node.alcn] = 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
+      if @data && @data[node.alcn]
+        @data[node.alcn].call
       else
         node.flag(:reinit)
         nil

data/lib/webgen/sourcehandler/metainfo.rb

@@ -22,15 +22,15 @@ module Webgen::SourceHandler
       self.nodes ||= []
     end
 
-    # Create a meta info node from +parent+ and +path+.
-    def create_node(parent, path)
+    # Create a meta info node from +path+.
+    def create_node(path)
       page = page_from_path(path)
-      super(parent, path) do |node|
+      super(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)
+              key = Webgen::Path.make_absolute(path.parent_path, key)
               node.node_info[mi_key][key] = value
             end
           end
@@ -38,13 +38,13 @@ module Webgen::SourceHandler
 
         mark_all_matched_dirty(node, :no_old_data)
 
-        website.cache.permanent[[:sh_metainfo_node_mi, node.absolute_lcn]] = {
+        website.cache.permanent[[:sh_metainfo_node_mi, node.alcn]] = {
           :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}
+        self.nodes = self.nodes.sort_by {|n| n.alcn}
       end
     end
 
@@ -62,7 +62,7 @@ module Webgen::SourceHandler
 
     # 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]]
+      cached = website.cache.permanent[[:sh_metainfo_node_mi, mi_node.alcn]]
       (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])
@@ -87,7 +87,7 @@ module Webgen::SourceHandler
     end
 
     # Update the meta info of matched path before a node is created.
-    def before_node_created(parent, path)
+    def before_node_created(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)
@@ -119,7 +119,7 @@ module Webgen::SourceHandler
     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])
+      website.cache.permanent.delete([:sh_metainfo_node_mi, node.alcn])
       self.nodes.delete(node)
     end
 

data/lib/webgen/sourcehandler/page.rb

@@ -12,13 +12,13 @@ module Webgen::SourceHandler
       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)
+    # Create a page file from +path+.
+    def create_node(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|
+      super(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
@@ -31,11 +31,12 @@ module Webgen::SourceHandler
       chain = [templates, node].flatten
 
       if chain.first.node_info[:page].blocks.has_key?(block_name)
-        node.node_info[:used_nodes] << chain.first.absolute_lcn
+        node.node_info[:used_nodes] << chain.first.alcn
         context = chain.first.node_info[:page].blocks[block_name].render(Webgen::Context.new(:chain => chain))
         context.content
       else
-        raise "Error rendering <#{node.absolute_lcn}>: no block named '#{block_name}' in <#{chain.first.absolute_lcn}>"
+        raise Webgen::RenderError.new("No block named '#{block_name}'",
+                                      self.class.name, node.alcn, chain.first.alcn)
       end
     end
     alias_method :content, :render_node

data/lib/webgen/sourcehandler/sitemap.rb

@@ -14,34 +14,34 @@ module Webgen::SourceHandler
     include Webgen::WebsiteAccess
     include Base
 
-    # Create an XML sitemap from +parent+ and +path+.
-    def create_node(parent, path)
-      page_from_path(path)
+    # Create an XML sitemap from +path+.
+    def create_node(path)
+      page = 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)
+      if path.meta_info['site_url'].nil?
+        raise Webgen::NodeCreationError.new("Needed information site_url is missing",
+                                            self.class.name, path)
+      end
+
+      super(path) do |node|
+        node.node_info[:sitemap] = page
+      end
     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
+      if node.node_info[:sitemap].blocks.has_key?('template')
+        node.node_info[:sitemap].blocks['template'].render(Webgen::Context.new(:chain => [node])).content
+      else
+        chain = [node.resolve("/templates/sitemap.template"), node]
+        node.node_info[:used_nodes] << chain.first.alcn
+        chain.first.node_info[:page].blocks['content'].render(Webgen::Context.new(:chain => chain)).content
       end
-      sitemap.target!
+    end
+
+    # Return the alcns of the sitemap +node+ as a flat list.
+    def alcns(node)
+      website.blackboard.invoke(:create_sitemap, node, node.lang, options_for_node(node)).to_lcn_list.flatten
     end
 
     #######

data/lib/webgen/sourcehandler/template.rb

@@ -9,30 +9,30 @@ module Webgen::SourceHandler
     include Webgen::Loggable
     include Base
 
-    # Create a template node in +parent+ for +path+.
-    def create_node(parent, path)
+    # Create a template node for +path+.
+    def create_node(path)
       page = page_from_path(path)
-      super(parent, path) do |node|
+      super(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]] ||= {})
+      cached_template = (website.cache.volatile[[node.alcn, :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!" }
+          log(:warn) { "Specified template '#{node['template']}' for <#{node.alcn}> 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}>" }
+        log(:info) { "Using default template in language '#{lang}' for <#{node.alcn}>" }
         template_node = default_template(node.parent, lang)
         if template_node == node && !node.parent.is_root?
           template_node = default_template(node.parent.parent, lang)

data/lib/webgen/sourcehandler/virtual.rb

@@ -19,26 +19,25 @@ module Webgen::SourceHandler
       @path_data = {}
     end
 
-    # Create all virtual nodes under +parent+ which are specified in +path+.
-    def create_node(parent, path)
+    # Create all virtual nodes which are specified in +path+.
+    def create_node(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)
+        key = Webgen::Path.make_absolute(path.parent_path, key) + (key =~ /\/$/ ? '/' : '')
+        temp_parent = create_directories(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))
+                       output_path : File.join(temp_parent.alcn, output_path))
 
         if key =~ /\/$/
-          nodes << create_directory(temp_parent, key, path, meta_info)
+          nodes << create_directory(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|
+          nodes += website.blackboard.invoke(:create_nodes, Webgen::Path.new(key, path.source_path), self) do |cn_path|
             cn_path.meta_info.update(meta_info)
-            super(cn_parent, cn_path, output_path) do |n|
+            super(cn_path, :output_path => output_path) do |n|
               n.node_info[:sh_virtual_cache_data] = cache_data
             end
           end
@@ -69,25 +68,28 @@ module Webgen::SourceHandler
     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)
+    def create_directories(dirname, path)
+      parent = website.tree.root
+      dirname.sub(/^\//, '').split('/').inject('/') do |parent_path, dir|
+        parent_path = File.join(parent_path, dir)
+        parent = create_directory(parent_path, path)
       end
       parent
     end
 
     # Create a virtual directory if it does not already exist.
-    def create_directory(parent, dir, path, meta_info = nil)
+    def create_directory(dir, path, meta_info = nil)
       dir_handler = website.cache.instance('Webgen::SourceHandler::Directory')
-      website.blackboard.invoke(:create_nodes, parent.tree, parent.absolute_lcn,
+      parent = website.tree.root
+      website.blackboard.invoke(:create_nodes,
                                 Webgen::Path.new(File.join(dir, '/'), path.source_path),
-                                dir_handler) do |par, temp_path|
-        parent = dir_handler.node_exists?(par, temp_path)
+                                dir_handler) do |temp_path|
+        parent = dir_handler.node_exists?(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)
+          parent = dir_handler.create_node(temp_path)
         end
         parent
       end