gettalong-webgen 0.5.5.20081010 → 0.5.5.20081012

data/doc/contentprocessor/fragments.page

@@ -0,0 +1,25 @@
+---
+title: Webgen::ContentProcessor::Fragments
+---
+## Description
+
+This processor generates nested fragment nodes from all headers `h1` to `h6` which have an `id`
+attribute set.
+
+> This is only done for the block named `content` or if no block is associated with the given render
+> context! This is to ensure that fragment nodes are not created from multiple block of one page
+> file. So this content processor has no effect when used in the pipeline of blocks except if the
+> block is named `content`.
+{.exclamation}
+
+The default markup language Maruku automatically generates an `id` attribute for all headers. If you
+use another markup language or plain old HTML, you might need to set the `id` attributes by hand.
+
+> The reason why only header tags with an `id` attribute are used is that only those can be
+> referenced and linked to later.
+{.information}
+
+The generated fragment nodes can be used like any other node. So you can link to them and use them
+in a menu. Concerning the menu, there is a setting for the `tag.menu.used_nodes` option called
+`fragments` which only uses the fragment node of the current page to generate a menu. This allows to
+generate a nice overview of the page.

data/doc/manual.page

@@ -429,21 +429,6 @@ As you might have deduced from the processing list above, it is possible that on
 multiple source handlers. This can be used, for example, to render an XML file as HTML and copy it
 verbatim.
 
-Internally a tree structure is created reflecting the source directory hierarchy and each path that
-is handled by webgen. Normally a source handler creates one node from one path but it is also
-possible that a source handler creates multiple nodes from one path.
-
-> The name used for describing a directory or file once it is placed in the internal tree structure
-> is 'node'.
-{.information}
-
-After this internal tree structure is created, it is traversed and each node is processed. First the
-node is checked if has changed (the notion of 'changed' depends on many things but a node is
-changed, for example, if its meta information or the associated source path has changed since the
-last webgen run). If it has not changed, nothing needs to be written. Otherwise, the information
-needed to write out the node is gathered and its content is written to the output path represented
-by the node.
-
 
 ## Path Meta Information {#source-metainfo}
 
@@ -521,6 +506,39 @@ There are several types of extensions:
 
 
 
+# A webgen Run
+
+When webgen is started, it first looks for a cache file and uses it if it exists. The cache file
+provides information on the previous run and allows webgen to render only those paths that have
+changed since the last time.
+
+Each webgen run consists of one or more update/write cycles. During the update phase the internal
+tree structure is updated to reflect the current situation:
+
+* Nodes are created from newly found source paths.
+* If a source path was deleted since the last webgen run, the nodes created from it will be deleted.
+* All nodes in the tree are checked if they have changed and, if so, are marked for regeneration.
+
+> The name used for describing a directory or file once it is placed in the internal tree structure
+> is 'node'.
+{.information}
+
+After the update cycle has finished, the internal tree representation is up-to-date and contains all
+necessary information to write its nodes. This is done in the write phase which writes out all
+changed nodes.
+
+It is possible that the internal tree structure changes during the write phase. For example, after
+writing a page file fragments node for it may have been generated. After the write phase it is
+checked if something like this has happened. If webgen finds such a condition, a new update/write
+cycle is initiated. This is done as long as needed.
+
+Since it is possible that multiple update/write cycles are used in one webgen run, it is shown in
+the log messages when a new cycle started. This is necessary because sometimes some warning or error
+log messages may be generated during an earlier cycle but the error conditions are automatically
+solved in later cycles. By marking where the cycles start a user can compare the log messages of the
+different cycles and see what he needs to solve himself.
+
+
 # Extending webgen
 
 If you know the programming language Ruby a little bit, you can easily extend webgen and add new

data/doc/reference_configuration.page

@@ -550,6 +550,19 @@ files in Webgen Page Format.
           Langbar with single language not shown: \{langbar: {show_single_lang: false}}
 
 
+*   ### tag.langbar.lang\_names
+
+    This configuration option can be used to specify the language names that should be displayed
+    instead of the language codes.
+
+    * Syntax: `\{CODE: NAME, ...}` where `CODE` is a language code and `NAME` the associated language
+      name of the code.
+
+    * Examples:
+
+          Langbar with custom language names: \{langbar: {lang_names: {de: Deutsch, en: English}}}
+
+
 *   ### tag.menu.used\_nodes
 
     Specifies the type of nodes that should be used for menu generation. If `all` is specified then

data/doc/reference_metainfo.page

@@ -60,6 +60,10 @@ never`.
 Sets the time when the path was created. This information cannot automatically be derived for paths
 provided by Webgen::Source::FileSystem, so this has to be set manually.
 
+> Note that the value needs to be a valid [YAML timestamp](http://yaml.org/type/timestamp.html) and
+> needs to include the time part.
+{.information}
+
 ### draft
 
 {:miref}
@@ -127,8 +131,13 @@ path.
 * Any
 
 Sets the time when the path was last modified. This information is automatically set for paths
-provided by Webgen::Source::FileSystem but can be overridden by setting it manually. If not set to a
-valid time, the time when webgen is executed is used for this meta information.
+provided by Webgen::Source::FileSystem (the file modification is used) but can be overridden by
+setting it manually. If not set to a valid time, the time when webgen is executed is used for this
+meta information.
+
+> Note that the value needs to be a valid [YAML timestamp](http://yaml.org/type/timestamp.html) and
+> needs to include the time part.
+{.information}
 
 ### no\_output
 

data/doc/sourcehandler/feed.page

@@ -14,6 +14,11 @@ The following meta information keys are supported:
     A LCN pattern (or an array of LCN patterns) which specify the page files that should be
     used. Other matched files are excluded from the list.
 
+    > Be aware that if you want to include a single file or files in a specific language only you
+    > need to include the language part since this is a LCN and not a CN pattern, eg. `mypage.html`
+    > won't work but `mypage.en.html` will!
+    {.information}
+
 *   `number_of_entries` (OPTIONAL)
 
     The number of entries that should be included in the feed. Defaults to 10.
@@ -26,6 +31,10 @@ The following meta information keys are supported:
 
     A RSS feed is generated if this key is set to `true`. Defaults to `true`.
 
+*   `rss_version` (OPTIONAL)
+
+    The RSS version that should be used for generating the RSS feed. Defaults to `2.0`.
+
 *   `site_url` (MANDATORY)
 
     The base url of the website for which the feed is generated.
@@ -48,11 +57,14 @@ The following meta information keys are supported:
 
 *   `created_at` (OPTIONAL)
 
-    The time at which this feed was created. Defaults to the current time if not set.
+    The time at which this feed was created. Defaults to the current time if not set. Has the same
+    format as the meta information `created_at`.
 
-*   `icon` (OPTIONAL)
+*   `content_block_name` (OPTIONAL)
 
-    The absolute localized canonical name of the feed's icon image.
+    The name of the block that should be used for the content of the feed entries. If not specified
+    the name `content` is used. Be aware that each page file that can appear in the feed needs to
+    have such a block!
 
 The following meta information keys of page files are used if they are specified:
 
@@ -65,6 +77,9 @@ The following meta information keys of page files are used if they are specified
     The time at which the page file was last modified, used as the time at which this feed entry was
     updated.
 
+    > This is the field that is used to sort the entries.
+    {.information}
+
 *   `title`
 
     The title of the page file, used as title of the feed entry.
@@ -79,4 +94,4 @@ The following meta information keys of page files are used if they are specified
 
 The default implementation supports the generation of atom and RSS feeds. You can override the
 default generation mechanism by adding an `atom_template` and/or `rss_template` block in the feed
-file which are then used to generate the atom or the RSS feed respectively.
+file which are then used to generate the atom or the RSS feed respectively.

data/doc/sourcehandler/page.page

@@ -12,19 +12,3 @@ meta information.
 set, the default language specified using the configuration option `website.lang` is used. This
 means that for the default language set to English and a source path named `index.page`, the
 language meta information is automatically set to English.
-
-## Fragment nodes
-
-The page handler automatically generates fragment nodes for all found header tags in the block named
-`content` (i.e. `h1`, `h2`, ...) that have an `id` attribute set. The default markup language Maruku
-automatically generates an `id` attribute for all headers. If you use another markup language or
-plain old HTML, you might need to set the `id` attributes by hand.
-
-> The reason why only header tags with an `id` attribute are used is that only those can be
-> referenced and linked to later.
-{.information}
-
-The generated fragment nodes can be used like any other node. So you can link to them and use them
-in a menu. Concerning the menu, there is a setting for the `tag.menu.used_nodes` option called
-`fragments` which only uses the fragment node of the current page to generate a menu. This allows to
-generate a nice overview of the page.

data/doc/tag/langbar.page

@@ -4,10 +4,13 @@ used_options:
   - tag.langbar.separator
   - tag.langbar.show_own_lang
   - tag.langbar.show_single_lang
+  - tag.langbar.lang_names
 ---
 ## Description
 
-This tag is used to display a list of links to translations of the page.
+This tag is used to display a list of links to translations of the page. The text that is displayed
+can be set via the configuration option `tag.langbar.lang_names` (if not set, the language code is
+shown).
 
 ## Examples
 
@@ -19,4 +22,8 @@ This tag is used to display a list of links to translations of the page.
   <td>\{langbar:}</td>
   <td>{langbar:}</td>
 </tr>
+<tr>
+  <td>\{langbar: {lang_names: {en: Englisch}}}</td>
+  <td>{langbar: {lang_names: {en: Englisch}}}</td>
+</tr>
 </table>

data/lib/webgen/contentprocessor.rb

@@ -65,6 +65,7 @@ module Webgen
     autoload :Builder, 'webgen/contentprocessor/builder'
     autoload :Erubis, 'webgen/contentprocessor/erubis'
     autoload :RDiscount, 'webgen/contentprocessor/rdiscount'
+    autoload :Fragments, 'webgen/contentprocessor/fragments'
 
     # Return the list of all available content processors.
     def self.list

data/lib/webgen/contentprocessor/fragments.rb

@@ -0,0 +1,23 @@
+module Webgen::ContentProcessor
+
+  # Uses the HTML headers h1, h2, ..., h6 to generate nested fragment nodes.
+  class Fragments
+
+    include Webgen::WebsiteAccess
+
+    # Generate the nested fragment nodes from <tt>context.content</tt> under
+    # <tt>content.content_node</tt> but only if there is no associated <tt>:block</tt> data in
+    # +context+ or the block is named +content+.
+    def call(context)
+      if !context[:block] || context[:block].name == 'content'
+        sections = website.blackboard.invoke(:parse_html_headers, context.content)
+        website.blackboard.invoke(:create_fragment_nodes, sections, context.content_node,
+                                  website.blackboard.invoke(:source_paths)[context.content_node.node_info[:src]],
+                                  context.content_node.meta_info['fragments_in_menu'])
+      end
+      context
+    end
+
+  end
+
+end

data/lib/webgen/default_config.rb

@@ -80,7 +80,7 @@ config.sourcehandler.default_meta_info({
                                          'Webgen::SourceHandler::Page' => {
                                            'kind' => 'page',
                                            'fragments_in_menu' => true,
-                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,maruku,blocks'}}
+                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,maruku,blocks,fragments'}}
                                          },
                                          'Webgen::SourceHandler::Fragment' => {
                                            'kind' => 'fragment'
@@ -131,6 +131,7 @@ config.contentprocessor.map({
                               'builder' => 'Webgen::ContentProcessor::Builder',
                               'erubis' => 'Webgen::ContentProcessor::Erubis',
                               'rdiscount' => 'Webgen::ContentProcessor::RDiscount',
+                              'fragments' => 'Webgen::ContentProcessor::Fragments',
                             }, :doc => 'Content processor name to class map')
 
 Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_names, Webgen::ContentProcessor.method(:list))
@@ -172,6 +173,7 @@ config.tag.breadcrumbtrail.end_level(-1, :doc => 'The level at which the breadcr
 config.tag.langbar.separator(' | ', :doc => 'Separates the languages from each other.')
 config.tag.langbar.show_single_lang(true, :doc => 'Should the link be shown although the page is only available in one language?')
 config.tag.langbar.show_own_lang(true, :doc => 'Should the link to the currently displayed language page be shown?')
+config.tag.langbar.lang_names({}, :doc => 'A map from language code to language names')
 
 config.tag.includefile.filename(nil, :doc => 'The name of the file which should be included (relative to the website).', :mandatory => 'default')
 config.tag.includefile.process_output(true, :doc => 'The file content will be scanned for tags if true.')

data/lib/webgen/languages.rb

@@ -50,6 +50,15 @@ module Webgen
       self.to_s <=> other.to_s
     end
 
+    def eql?(other) #:nodoc:
+      (other.is_a?(self.class) && other.to_s == self.to_s) ||
+        (other.is_a?(String) && self.to_s == other)
+    end
+
+    def hash #:nodoc:
+      self.to_s.hash
+    end
+
   end
 
 

data/lib/webgen/logger.rb

@@ -27,11 +27,28 @@ module Webgen
       end
       self.level = ::Logger::WARN
       self.verbosity = :normal
+      @marks = []
     end
 
     # Returns the output of the logger when #sync is +false+. Otherwise an empty string is returned.
     def log_output
-      @sync ? '' : @logio.string
+      if @sync
+        ''
+      else
+        out = @logio.string.dup
+        @marks.reverse.each_with_index do |mark, index|
+          out.insert(mark, " INFO -- Log messages for run #{@marks.length - index} are following\n")
+        end if out.length > 0
+        out
+      end
+    end
+
+    # Only used when #sync is +false: Mark the location in the log stream where a new update/write
+    # run begins.
+    def mark_new_cycle
+      if !@sync
+        @marks << @logio.string.length
+      end
     end
 
     # The severity threshold level.

data/lib/webgen/node.rb

@@ -77,7 +77,7 @@ module Webgen
     def reinit(path, meta_info = {})
       old_path = @path
       @path = path.freeze
-      @lang = meta_info.delete('lang').freeze
+      @lang = Webgen::LanguageManager.language_for_code(meta_info.delete('lang'))
       @lang = nil unless is_file?
       @meta_info = meta_info
       @flags = Set.new([:dirty, :created])

data/lib/webgen/page.rb

@@ -106,7 +106,7 @@ module Webgen
           options, content = *block_data
           md = RE_BLOCKS_OPTIONS.match(options.to_s)
           raise(WebgenPageFormatError, "Found invalid blocks starting line for block #{index+1}: #{options}") if content =~ /\A---/ || md.nil?
-          options = Hash[*md[1].to_s.scan(/(\w+):([^\s]*)/).map {|k,v| [k, YAML::load(v)]}.flatten]
+          options = Hash[*md[1].to_s.scan(/(\w+):([^\s]*)/).map {|k,v| [k, (v == '' ? nil : YAML::load(v))]}.flatten]
           options = (meta_info['blocks']['default'] || {} rescue {}).
             merge((meta_info['blocks'][index+1] || {} rescue {})).
             merge(options)

data/lib/webgen/sourcehandler.rb

@@ -41,8 +41,11 @@ module Webgen
       # are checked (nodes for deleted sources are deleted, nodes for new and changed sources).
       def render(tree)
         begin
+          website.logger.mark_new_cycle if website.logger
+
           puts "Updating tree..."
           time = Benchmark.measure do
+            website.cache.reset_volatile_cache
             update_tree(tree)
           end
           puts "...done in " + ('%2.4f' % time.real) + ' seconds'

data/lib/webgen/sourcehandler/feed.rb

@@ -46,8 +46,7 @@ module Webgen::SourceHandler
           render(Webgen::ContentProcessor::Context.new(:chain => [node])).content
       else
         feed = (website.cache.volatile[:sourcehandler_feed] ||= {})[node.node_info[:src]] ||= build_feed_for(node)
-        feed.feed_type = node.node_info[:feed_type]
-        feed.build_xml
+        feed.build_xml(node.node_info[:feed_type], (node.node_info[:feed_type] == 'rss' ? node['rss_version'] || 2.0 : nil))
       end
     end
 
@@ -58,8 +57,7 @@ module Webgen::SourceHandler
 
       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']}.
-        reverse[0, nr_items]
+        sort {|a,b| a['modified_at'] <=> b['modified_at']}[0, nr_items]
     end
 
     #######
@@ -85,13 +83,12 @@ module Webgen::SourceHandler
       feed.published = (node['created_at'].kind_of?(Time) ? node['created_at'] : Time.now)
       feed.updated = Time.now
       feed.generator = 'webgen - Webgen::SourceHandler::Feed'
-      feed.icon = File.join(site_url, node.tree[node['icon']].path) if node['icon']
 
       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['content'].render(Webgen::ContentProcessor::Context.new(:chain => [entry])).content
+        item.content = entry.node_info[:page].blocks[node['content_block_name'] || 'content'].render(Webgen::ContentProcessor::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']

data/lib/webgen/sourcehandler/page.rb

@@ -18,23 +18,7 @@ module Webgen::SourceHandler
 
       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
-        tmp_logger = website.logger
-        website.logger = nil    # disabling logging whiling creating fragment nodes
-
-        website.cache.permanent[:page_sections] ||= {}
-        sections = if path.changed? || !website.cache.permanent[:page_sections][node.absolute_lcn]
-                     website.blackboard.invoke(:parse_html_headers, render_node(node, 'content', []))
-                   else
-                     website.cache.permanent[:page_sections][node.absolute_lcn]
-                   end
-        website.cache.permanent[:page_sections][node.absolute_lcn] = sections
-        website.blackboard.invoke(:create_fragment_nodes,
-                                  sections,
-                                  node, website.blackboard.invoke(:source_paths)[path.source_path],
-                                  node.meta_info['fragments_in_menu'])
-        website.logger = tmp_logger
       end
     end
 

data/lib/webgen/tag/langbar.rb

@@ -17,7 +17,7 @@ module Webgen::Tag
       result = lang_nodes.
         reject {|n| (context.content_node.lang == n.lang && !param('tag.langbar.show_own_lang'))}.
         sort {|a, b| a.lang <=> b.lang}.
-        collect {|n| context.dest_node.link_to(n, :link_text => n.lang, :lang => n.lang)}.
+        collect {|n| context.dest_node.link_to(n, :link_text => (param('tag.langbar.lang_names')[n.lang] || n.lang), :lang => n.lang)}.
         join(param('tag.langbar.separator'))
       (param('tag.langbar.show_single_lang') || lang_nodes.length > 1 ? result : "")
     end

data/lib/webgen/tree.rb

@@ -56,8 +56,9 @@ module Webgen
 
     # A utility method called by Node#reinit. This method should not be used directly!
     def register_path(node)
+      return if node['no_output']
       if @node_access[:path].has_key?(node.path)
-        raise "Can't have two nodes with same output path: #{node.path}" unless node['no_output']
+        raise "Can't have two nodes with same output path: #{node.path}"
       else
         @node_access[:path][node.path] = node
       end

data/test/test_contentprocessor_fragments.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'test/helper'
+require 'webgen/page'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorFragments < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_process
+    Webgen::SourceHandler::Main.new
+    @website.blackboard.del_service(:source_paths)
+    @website.blackboard.add_service(:source_paths) { Hash.new(path_with_meta_info('/')) }
+
+    obj = Webgen::ContentProcessor::Fragments.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    root.node_info[:src] = '/'
+    processors = { 'fragments' => obj }
+
+    context = Webgen::ContentProcessor::Context.new(:chain => [root], :processors => processors)
+    context.content = '<h1 id="test">Test</h1><h1>Test2</h1>'
+    obj.call(context)
+    assert(root.tree['/#test'])
+    assert_equal(3, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/#test')
+
+    context[:block] = Webgen::Block.new('content', '', {})
+    obj.call(context)
+    assert(root.tree['/#test'])
+    assert_equal(3, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/#test')
+
+    context[:block] = Webgen::Block.new('other', '', {})
+    obj.call(context)
+    assert(!root.tree['/#test'])
+    assert_equal(2, root.tree.node_access[:alcn].length)
+  end
+
+end

data/test/test_languages.rb

@@ -50,4 +50,16 @@ class TestLanguages < Test::Unit::TestCase
     assert_equal(-1, ace <=> eng)
   end
 
+  def test_hashing
+    de = Webgen::LanguageManager.language_for_code('ger')
+    en = Webgen::LanguageManager.language_for_code('en')
+    h = {'de' => de, en => en}
+    assert_equal(de, h[de])
+    assert_equal(de, h['de'])
+    assert_equal(en, h[en])
+    assert_not_equal(en, h['en']) # bc 'en'.eql?(en) is false
+    assert_equal(Webgen::LanguageManager.language_for_code('en'),
+                 Webgen::LanguageManager.language_for_code(en))
+  end
+
 end

data/test/test_logger.rb

@@ -70,4 +70,23 @@ class TestLogger < Test::Unit::TestCase
     assert_equal("ERROR -- hallo\n", l.log_output)
   end
 
+  def test_run_marks
+    l = Webgen::Logger.new(io = StringIO.new, true)
+    l.mark_new_cycle
+    l.error { 'hallo' }
+    assert_equal("", l.log_output)
+
+    l = Webgen::Logger.new(io = StringIO.new, false)
+    l.error { 'hallo' }
+    l.mark_new_cycle
+    l.error { 'other' }
+    l.mark_new_cycle
+    assert_equal("ERROR -- hallo\n INFO -- Log messages for run 1 are following\n" +
+                 "ERROR -- other\n INFO -- Log messages for run 2 are following\n", l.log_output)
+
+    l = Webgen::Logger.new(io = StringIO.new, false)
+    l.mark_new_cycle
+    assert_equal("", l.log_output)
+  end
+
 end

data/test/test_node.rb

@@ -39,6 +39,7 @@ class TestNode < Test::Unit::TestCase
       assert_equal(lcn, node.lcn)
       assert_equal(alcn, node.absolute_lcn)
       assert_equal(lang, node.lang)
+      assert_kind_of(Webgen::Language, node.lang) if node.lang
       assert(node.flagged(:dirty))
       assert(node.flagged(:created))
       assert_equal(mi, node.meta_info)

data/test/test_page.rb

@@ -97,14 +97,14 @@ class TestPage < Test::Unit::TestCase
     --- name:block
     content doing -
     with?: with some things
-    --- other:options test1:true test2:false test3:542
+    --- other:options test1:true test2:false test3:542 pipeline:
   meta_info: {}
   blocks:
     - name: block
       content: "content doing -\\nwith?: with some things"
     - name: block2
       content: ''
-      options: {other: options, test1: true, test2: false, test3: 542}
+      options: {other: options, test1: true, test2: false, test3: 542, pipeline: ~}
 
 # block with seemingly block start line it
 - in: |

data/test/test_sourcehandler_feed.rb

@@ -12,6 +12,7 @@ class TestSourceHandlerFeed < Test::Unit::TestCase
 site_url: http://example.com
 entries: *.html
 author: Thomas Leitner
+content_block_name: abstract
 --- name:rss_template
 hallo
 EOF
@@ -22,7 +23,7 @@ EOF
       :file1_en => Webgen::Node.new(root, '/file1.en.html', 'file1.html', {'lang' => 'en', 'in_menu' => true, 'modified_at' => Time.now}),
       :index_en => Webgen::Node.new(root, '/index.en.html', 'index.html', {'lang' => 'en', 'modified_at' => Time.now - 1, 'author' => 'test'}),
     }
-    @nodes[:index_en].node_info[:page] = Webgen::Page.from_data("hallo")
+    @nodes[:index_en].node_info[:page] = Webgen::Page.from_data("--- name:content\nMyContent\n--- name:abstract\nRealContent")
     @obj = Webgen::SourceHandler::Feed.new
     @path = path_with_meta_info('/test.feed', {}, @obj.class.name) {StringIO.new(FEED_CONTENT)}
   end
@@ -43,6 +44,7 @@ EOF
     atom_node, rss_node = @obj.create_node(@nodes[:root], @path)
     assert_equal('hallo', rss_node.content)
     assert(atom_node.content =~ /Thomas Leitner/)
+    assert(atom_node.content =~ /RealContent/)
   end
 
   def test_feed_entries

data/test/test_sourcehandler_page.rb

@@ -10,11 +10,7 @@ class TestSourceHandlerPage < Test::Unit::TestCase
   def setup
     super
     @website.blackboard.del_service(:templates_for_node)
-    @website.blackboard.del_service(:parse_html_sections)
-    @website.blackboard.del_service(:create_fragment_nodes)
     @website.blackboard.add_service(:templates_for_node) {|node| []}
-    @website.blackboard.add_service(:parse_html_sections) {[]}
-    @website.blackboard.add_service(:create_fragment_nodes) {nil}
     @obj = Webgen::SourceHandler::Page.new
     @root = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'test/', 'test')
     @path = path_with_meta_info('/index.page') {StringIO.new('content')}
@@ -32,7 +28,6 @@ class TestSourceHandlerPage < Test::Unit::TestCase
     assert_equal('yes', node['test'])
     assert_equal(6, node['sort_info'])
     assert_equal(Webgen::LanguageManager.language_for_code('epo'), node.lang)
-    assert_not_nil(@website.cache.permanent[:page_sections]['/test/index.eo.html'])
 
     assert_equal(node, @obj.create_node(@root, @path.dup))
 

data/test/test_tag_langbar.rb

@@ -31,7 +31,13 @@ class TestTagLangbar < Test::Unit::TestCase
     check_results(nodes[:file_en], link, '', '', '')
 
     @obj.set_params('tag.langbar.show_single_lang' => true, 'tag.langbar.show_own_lang' => true, 'tag.langbar.separator' => ' --- ')
-    assert_equal("#{de_link} --- #{en_link}", @obj.call('langbar', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:index_en]])))
+    assert_equal("#{de_link} --- #{en_link}",
+                 @obj.call('langbar', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:index_en]])))
+
+    @obj.set_params('tag.langbar.show_single_lang' => true, 'tag.langbar.show_own_lang' => true,
+                    'tag.langbar.lang_names' => {'de' => 'Deutsch'})
+    assert_equal("<a href=\"index.de.html\">Deutsch</a> | #{en_link}",
+                 @obj.call('langbar', '', Webgen::ContentProcessor::Context.new(:chain => [nodes[:index_en]])))
 
     nodes[:index_en].unflag(:dirty)
     @website.blackboard.dispatch_msg(:node_changed?, nodes[:index_en])

data/test/test_tree.rb

@@ -20,8 +20,8 @@ class TestTree < Test::Unit::TestCase
     assert_equal(root, @tree.root)
   end
 
-  def test_register_node
-    # Tree#register_node is called when creating a node
+  def test_register_node_and_register_path
+    # Tree#register_node/_path is called when creating a node
     node = Webgen::Node.new(@tree.dummy_root, 'dummy/', 'dummy')
     assert_equal(node, @tree['/dummy', :alcn])
     assert_equal(node, @tree['/dummy', :acn])
@@ -29,6 +29,8 @@ class TestTree < Test::Unit::TestCase
     assert_raise(RuntimeError) { Webgen::Node.new(@tree.dummy_root, '/', 'dummy') }
     assert_raise(RuntimeError) { Webgen::Node.new(@tree.dummy_root, 'dummy/', 'other') }
     assert_nothing_raised { Webgen::Node.new(@tree.dummy_root, 'dummy/', 'unknown', {'no_output' => true}) }
+    Webgen::Node.new(@tree.dummy_root, 'new', 'new', {'no_output' => true})
+    assert(!@tree['new', :path])
   end
 
   def test_delete_node

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gettalong-webgen
 version: !ruby/object:Gem::Version 
-  version: 0.5.5.20081010
+  version: 0.5.5.20081012
 platform: ruby
 authors: 
 - Thomas Leitner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-09 15:00:00 -07:00
+date: 2008-10-11 15:00:00 -07:00
 default_executable: webgen
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -360,6 +360,7 @@ files:
 - doc/contentprocessor/builder.page
 - doc/contentprocessor/erb.page
 - doc/contentprocessor/erubis.page
+- doc/contentprocessor/fragments.page
 - doc/contentprocessor/haml.page
 - doc/contentprocessor/maruku.page
 - doc/contentprocessor/rdiscount.page
@@ -417,6 +418,7 @@ files:
 - lib/webgen/contentprocessor/context.rb
 - lib/webgen/contentprocessor/erb.rb
 - lib/webgen/contentprocessor/erubis.rb
+- lib/webgen/contentprocessor/fragments.rb
 - lib/webgen/contentprocessor/haml.rb
 - lib/webgen/contentprocessor/maruku.rb
 - lib/webgen/contentprocessor/rdiscount.rb
@@ -492,6 +494,7 @@ files:
 - test/test_contentprocessor_context.rb
 - test/test_contentprocessor_erb.rb
 - test/test_contentprocessor_erubis.rb
+- test/test_contentprocessor_fragments.rb
 - test/test_contentprocessor_haml.rb
 - test/test_contentprocessor_maruku.rb
 - test/test_contentprocessor_rdiscount.rb