gettalong-webgen 0.5.8.20090507 → 0.5.9.20090620

data/test/test_contentprocessor_builder.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
@@ -10,7 +11,7 @@ class TestContentProcessorBuilder < Test::Unit::TestCase
     obj = Webgen::ContentProcessor::Builder.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
-    content = "xml.div(:path => context.node.absolute_lcn) { xml.strong('test'); " +
+    content = "xml.div(:path => context.node.alcn) { xml.strong('test'); " +
       "context.website; context; context.ref_node; context.dest_node }"
     context = Webgen::Context.new(:content => content,
                                                     :chain => [node])

data/test/test_contentprocessor_erb.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
@@ -10,7 +11,7 @@ class TestContentProcessorErb < Test::Unit::TestCase
     obj = Webgen::ContentProcessor::Erb.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
-    content = "<%= context[:doit] %>6\n<%= context.ref_node.absolute_lcn %>\n<%= context.node.absolute_lcn %>\n<%= context.dest_node.absolute_lcn %><% website %>"
+    content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% website %>"
     context = Webgen::Context.new(:content => content, :doit => 'hallo',
                                                     :chain => [node])
     obj.call(context)

data/test/test_contentprocessor_erubis.rb

@@ -17,7 +17,7 @@ class TestContentProcessorErubis < Test::Unit::TestCase
     node = Webgen::Node.new(root, 'test', 'test')
     context = Webgen::Context.new(:doit => 'hallo', :chain => [node])
 
-    context.content = "<%= context[:doit] %>6\n<%= context.ref_node.absolute_lcn %>\n<%= context.node.absolute_lcn %>\n<%= context.dest_node.absolute_lcn %><% context.website %>"
+    context.content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% context.website %>"
     assert_equal("hallo6\n/test\n/test\n/test", obj.call(context).content)
 
     context.content = '<%= 5* %>'

data/test/test_contentprocessor_fragments.rb

@@ -13,30 +13,31 @@ class TestContentProcessorFragments < Test::Unit::TestCase
   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('/')) }
+    @website.blackboard.add_service(:source_paths) { Hash.new(path_with_meta_info('/test.html')) }
 
     obj = Webgen::ContentProcessor::Fragments.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
-    root.node_info[:src] = '/'
+    node = Webgen::Node.new(root, '/test.html', 'test.html')
+    node.node_info[:src] = '/test.html'
     processors = { 'fragments' => obj }
 
-    context = Webgen::Context.new(:chain => [root], :processors => processors)
+    context = Webgen::Context.new(:chain => [node], :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')
+    assert(root.tree['/test.html#test'])
+    assert_equal(4, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/test.html#test')
 
     context[:block] = Webgen::Page::Block.new('content', '', {})
     obj.call(context)
-    assert(root.tree['/#test'])
-    assert_equal(3, root.tree.node_access[:alcn].length)
-    root.tree.delete_node('/#test')
+    assert(root.tree['/test.html#test'])
+    assert_equal(4, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/test.html#test')
 
     context[:block] = Webgen::Page::Block.new('other', '', {})
     obj.call(context)
-    assert(!root.tree['/#test'])
-    assert_equal(2, root.tree.node_access[:alcn].length)
+    assert(!root.tree['/test.html#test'])
+    assert_equal(3, root.tree.node_access[:alcn].length)
   end
 
 end

data/test/test_contentprocessor_haml.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
@@ -10,7 +11,7 @@ class TestContentProcessorHaml < Test::Unit::TestCase
     obj = Webgen::ContentProcessor::Haml.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
-    content = "#content\n  %h1 Hallo\n  = [context.node.absolute_lcn, context.ref_node.absolute_lcn, context.dest_node.absolute_lcn, context.website, context.dest_node.absolute_lcn].join"
+    content = "#content\n  %h1 Hallo\n  = [context.node.alcn, context.ref_node.alcn, context.dest_node.alcn, context.website, context.dest_node.alcn].join"
     context = Webgen::Context.new(:content => content,
                                                     :chain => [node])
     obj.call(context)

data/test/test_contentprocessor_maruku.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/node'
 require 'webgen/tree'
 require 'webgen/contentprocessor'

data/test/test_contentprocessor_rdiscount.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/node'
 require 'webgen/tree'
 require 'webgen/contentprocessor'

data/test/test_contentprocessor_rdoc.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 

data/test/test_contentprocessor_sass.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 

data/test/test_contentprocessor_tags.rb

@@ -15,6 +15,8 @@ class TestContentProcessorTags < Test::Unit::TestCase
 
     def create_tag_params(*args); end
 
+    def create_params_hash(*args); end
+
     def call(tag, body, context)
       case tag
       when 'body'
@@ -46,6 +48,17 @@ class TestContentProcessorTags < Test::Unit::TestCase
                   @obj.call(context.clone(:content => "test{bodyproc::} \\{other:}{other:} {bodyproc}test")).content)
   end
 
+  def test_process_tag
+    context = Webgen::Context.new(:chain => [Webgen::Tree.new.dummy_root])
+    context.content = "{test: }"
+    assert_equal('', @obj.process_tag('test', {}, '', context))
+
+    add_test_tag
+    assert_equal('test', @obj.process_tag('test', {'something' => 'new'}, '', context))
+    assert_equal('test', @obj.process_tag('test', '{something: new}', '', context))
+    assert_equal('thebody', @obj.process_tag('body', '{something: new}', 'thebody', context))
+  end
+
   def test_replace_tags
     check_returned_tags('sdfsdf{asd', [])
     check_returned_tags('sdfsdf}asd', [])

data/test/test_context.rb

@@ -6,7 +6,10 @@ require 'webgen/context'
 
 class TestContext < Test::Unit::TestCase
 
+  include Test::WebsiteHelper
+
   def setup
+    super
     @context = Webgen::Context.new(:content => 'test', :key => :value, :chain => [:first, :last])
   end
 
@@ -39,4 +42,29 @@ class TestContext < Test::Unit::TestCase
     assert_equal(:other, @context.dest_node)
   end
 
+  def test_tags_methods
+    @context[:chain] = [Webgen::Tree.new.dummy_root]
+
+    klass = Class.new do
+      def set_params(*args); end
+      def create_tag_params(*args); end
+      def create_params_hash(*args); end
+      def call(tag, body, context); 'mivalue'; end
+    end
+    (@website.cache.volatile[:classes] ||= {})['TestTag'] = klass.new
+    @website.config['contentprocessor.tags.map'].update(:default => 'TestTag')
+
+    assert_equal('mivalue', @context.tag('mivalue'))
+  end
+
+  def test_render_methods
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    node.node_info[:page] = Webgen::Page.from_data("--- name:content\ndata\n--- name:other\nother")
+    @context[:chain] = [root, node]
+
+    assert_equal('data', @context.render_block('content'))
+    assert_equal('other', @context.render_block(:name => 'other'))
+  end
+
 end

data/test/test_node.rb

@@ -11,7 +11,7 @@ class TestNode < Test::Unit::TestCase
 
   def setup
     super
-    @tree = Webgen::Tree.new
+    @tree = @website.tree
   end
 
   def create_default_nodes
@@ -39,7 +39,7 @@ class TestNode < Test::Unit::TestCase
       assert_equal(path, node.path)
       assert_equal(cn, node.cn)
       assert_equal(lcn, node.lcn)
-      assert_equal(alcn, node.absolute_lcn)
+      assert_equal(alcn, node.alcn)
       assert_equal(lang, node.lang)
       assert_kind_of(Webgen::Language, node.lang) if node.lang
       assert(node.flagged?(:dirty))
@@ -49,22 +49,22 @@ class TestNode < Test::Unit::TestCase
       mi.each {|k,v| assert_equal(v, node[k])}
     end
 
-    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
-    check_proc.call(node, @tree.dummy_root, 'test/', 'test', 'test', '/test', nil, {:test => :value})
+    node = Webgen::Node.new(@tree.dummy_root, '/', '/', {'lang' => 'de', :test => :value})
+    check_proc.call(node, @tree.dummy_root, '/', '/', '/', '/', nil, {:test => :value})
 
     child = Webgen::Node.new(node, 'somename.html', 'somename.page',  {'lang' => 'de'})
     check_proc.call(child, node, 'somename.html', 'somename.page', 'somename.de.page',
-                    '/test/somename.de.page', 'de', {})
+                    '/somename.de.page', 'de', {})
 
     ['http://webgen.rubyforge.org', 'c:\\test'].each_with_index do |abspath, index|
       cn = 'test' + index.to_s + '.html'
       c = Webgen::Node.new(node, abspath, cn)
-      check_proc.call(c, node, abspath, cn, cn, '/test/' + cn, nil, {})
+      check_proc.call(c, node, abspath, cn, cn, '/' + cn, nil, {})
     end
 
     child.reinit('somename.en.html', {'lang' => 'de', 'title' => 'test'})
     check_proc.call(child, node, 'somename.en.html', 'somename.page', 'somename.de.page',
-                    '/test/somename.de.page', 'de', {'title' => 'test'})
+                    '/somename.de.page', 'de', {'title' => 'test'})
   end
 
   def test_type_checkers
@@ -156,12 +156,26 @@ class TestNode < Test::Unit::TestCase
     assert_equal(nodes[:dir2_index_en], nodes[:dir2].resolve('index.html', 'en'))
 
     assert_equal(nodes[:dir], nodes[:somename_en].resolve('/dir/'))
+    assert_equal(nodes[:dir], nodes[:somename_en].resolve('/dir'))
     assert_equal(nodes[:root], nodes[:somename_en].resolve('/'))
   end
 
+  def test_resolve_passive_nodes
+    nodes = create_default_nodes
+
+    assert_nil(nodes[:root].resolve('/images/webgen_logo.png'))
+
+    shm = Webgen::SourceHandler::Main.new
+    @website.config['passive_sources'] << ['/', "Webgen::Source::Resource", "webgen-passive-sources"]
+    node = nodes[:root].resolve('/images/webgen_logo.png')
+    assert_not_nil(node)
+    assert_equal('/images/webgen_logo.png', node.alcn)
+    assert_equal(['/images/', '/images/webgen_logo.png'].to_set, node.node_info[:used_meta_info_nodes])
+  end
+
   def test_introspection
-    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
-    assert(node.inspect =~ /alcn=\/test/)
+    node = Webgen::Node.new(@tree.dummy_root, '/', '/', {'lang' => 'de', :test => :value})
+    assert(node.inspect =~ /alcn=\//)
   end
 
   def test_changed
@@ -177,16 +191,16 @@ class TestNode < Test::Unit::TestCase
 
     # Test :used_nodes array checking
     node.unflag(:dirty)
-    node.node_info[:used_nodes] << node.absolute_lcn
+    node.node_info[:used_nodes] << node.alcn
     node.node_info[:used_nodes] << 'unknown alcn'
-    node.node_info[:used_nodes] << @tree.dummy_root.absolute_lcn
+    node.node_info[:used_nodes] << @tree.dummy_root.alcn
     assert(node.changed?)
     assert_equal(1, calls)
 
     # Test :used_nodes array checking
     node.unflag(:dirty)
     node.node_info[:used_nodes] = Set.new
-    node.node_info[:used_meta_info_nodes] << node.absolute_lcn
+    node.node_info[:used_meta_info_nodes] << node.alcn
     assert(node.changed?)
     assert_equal(2, calls)
     node.unflag(:dirty)
@@ -198,8 +212,8 @@ class TestNode < Test::Unit::TestCase
     other_node = Webgen::Node.new(@tree.dummy_root, '/other', 'test.l', {'lang' => 'de', :test => :value})
     other_node.flag(:dirty, :created)
     node.flag(:dirty)
-    other_node.node_info[:used_nodes] = [node.absolute_lcn]
-    node.node_info[:used_nodes] = [other_node.absolute_lcn]
+    other_node.node_info[:used_nodes] = [node.alcn]
+    node.node_info[:used_nodes] = [other_node.alcn]
     node.changed?
   end
 
@@ -234,12 +248,6 @@ class TestNode < Test::Unit::TestCase
     assert(node !~ '**/*.test')
   end
 
-  def test_absolute_name
-    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
-    node = Webgen::Node.new(root, 'somepath', 'somefile.html', {'lang' => 'de'})
-    assert_equal('/somefile.de.html', node.absolute_lcn)
-  end
-
   def test_route_to
     nodes = create_default_nodes
 
@@ -363,5 +371,17 @@ class TestNode < Test::Unit::TestCase
                  nodes[:somename_en_frag].link_to(nodes[:somename_en_frag]))
   end
 
+  def test_url
+    assert_equal("webgen://webgen.localhost/hallo", Webgen::Node.url("hallo").to_s)
+    assert_equal("webgen://webgen.localhost/hallo%20du", Webgen::Node.url("hallo du").to_s)
+    assert_equal("webgen://webgen.localhost/hall%C3%B6chen", Webgen::Node.url("hallöchen").to_s)
+    assert_equal("webgen://webgen.localhost/hallo#du", Webgen::Node.url("hallo#du").to_s)
+
+    assert_equal("webgen://webgen.localhost/test", Webgen::Node.url("/test").to_s)
+    assert_equal("http://example.com/test", Webgen::Node.url("http://example.com/test").to_s)
+
+    assert_equal("test", Webgen::Node.url("test", false).to_s)
+    assert_equal("http://example.com/test", Webgen::Node.url("http://example.com/test", false).to_s)
+  end
 
 end

data/test/test_path.rb

@@ -6,75 +6,105 @@ require 'stringio'
 
 class TestPath < Test::Unit::TestCase
 
-  def test_initialize
-    check_proc = proc do |o, path, dir, bn, lang, ext, cn, oi, title|
-      assert_equal(path, o.path)
-      assert_equal(path, o.source_path)
-      assert_equal(dir, o.directory)
-      assert_equal(bn, o.cnbase)
+  def test_initialize_and_accessors
+    check_proc = proc do |o, ppath, bn, lang, ext, cn, lcn, acn, alcn, oi, title|
+      assert_kind_of(String, o.path)
+      assert_equal(o.path, o.source_path)
+      assert_equal(ppath, o.parent_path)
+      assert_equal(bn, o.basename)
       assert_equal(lang, o.meta_info['lang'])
       assert_equal(ext, o.ext)
       assert_equal(cn, o.cn)
+      assert_equal(lcn, o.lcn)
+      assert_equal(acn, o.acn)
+      assert_equal(alcn, o.alcn)
       assert_equal(oi, o.meta_info['sort_info'])
       assert_equal(title, o.meta_info['title'])
     end
-    check_proc.call(Webgen::Path.new('5.base_name-one.de.page'),
-                    '5.base_name-one.de.page', './', 'base_name-one', 'de', 'page', 'base_name-one.page', 5, 'Base name one')
-    check_proc.call(Webgen::Path.new('dir/default.png'),
-                    'dir/default.png', 'dir/', 'default', nil, 'png', 'default.png', nil, 'Default')
-    check_proc.call(Webgen::Path.new('default.en.png'),
-                    'default.en.png', './', 'default', 'en', 'png', 'default.png', nil, 'Default')
-    check_proc.call(Webgen::Path.new('default.deu.png'),
-                    'default.deu.png', './', 'default', 'de', 'png', 'default.png', nil, 'Default')
-    check_proc.call(Webgen::Path.new('default.template'),
-                    'default.template', './', 'default', nil, 'template', 'default.template', nil, 'Default')
-    check_proc.call(Webgen::Path.new('default.en.tar.bz2'),
-                    'default.en.tar.bz2', './', 'default', 'en', 'tar.bz2', 'default.tar.bz2', nil, 'Default')
-    check_proc.call(Webgen::Path.new('default.tar.bz2'),
-                    'default.tar.bz2', './', 'default', nil, 'tar.bz2', 'default.tar.bz2', nil, 'Default')
-    check_proc.call(Webgen::Path.new('default'),
-                    'default', './', 'default', nil, '', 'default', nil, 'Default')
-    check_proc.call(Webgen::Path.new('.htaccess'),
-                    '.htaccess', './', '', nil, 'htaccess', '.htaccess', nil, '')
 
+    # Check directory paths
     check_proc.call(Webgen::Path.new('/'),
-                    '/', '/', '/', nil, '', '/', nil, '/')
-    check_proc.call(Webgen::Path.new('/dir/'),
-                    '/dir/', '/', 'dir', nil, '', 'dir', nil, 'Dir')
+                    '', '/', nil, '', '/', '/', '/', '/', nil, '/')
+    check_proc.call(Webgen::Path.new('/directory/'),
+                    '/', 'directory', nil, '', 'directory/', 'directory/', '/directory/', '/directory/', nil, 'Directory')
+    check_proc.call(Webgen::Path.new('/dir1/dir2.ext/'),
+                    '/dir1/', 'dir2.ext', nil, '', 'dir2.ext/', 'dir2.ext/', '/dir1/dir2.ext/', '/dir1/dir2.ext/', nil, 'Dir2.ext')
+
+    # Check file paths
+    check_proc.call(Webgen::Path.new('/5.b_n-one.de.page'),
+                    '/', 'b_n-one', 'de', 'page', 'b_n-one.page', 'b_n-one.de.page',  '/b_n-one.page', '/b_n-one.de.page', 5, 'B n one')
+    check_proc.call(Webgen::Path.new('/dir/default.png'),
+                    '/dir/',  'default', nil, 'png', 'default.png', 'default.png', '/dir/default.png', '/dir/default.png', nil, 'Default')
+    check_proc.call(Webgen::Path.new('/default.deu.png'),
+                    '/', 'default', 'de', 'png', 'default.png', 'default.de.png', '/default.png', '/default.de.png', nil, 'Default')
+    check_proc.call(Webgen::Path.new('/default.en.tar.bz2'),
+                    '/', 'default', 'en', 'tar.bz2', 'default.tar.bz2', 'default.en.tar.bz2', '/default.tar.bz2', '/default.en.tar.bz2', nil, 'Default')
+    check_proc.call(Webgen::Path.new('/default.deu.'),
+                    '/',  'default', 'de', '', 'default', 'default.de', '/default', '/default.de', nil, 'Default')
+    check_proc.call(Webgen::Path.new('/default'),
+                    '/', 'default', nil, '', 'default', 'default', '/default', '/default', nil, 'Default')
+    check_proc.call(Webgen::Path.new('/.htaccess'),
+                    '/', '.htaccess', nil, '', '.htaccess', '.htaccess', '/.htaccess', '/.htaccess', nil, '.htaccess')
+    check_proc.call(Webgen::Path.new('/.htaccess.page'),
+                    '/', '.htaccess', nil, 'page', '.htaccess.page', '.htaccess.page', '/.htaccess.page', '/.htaccess.page', nil, '.htaccess')
+    check_proc.call(Webgen::Path.new('/.htaccess.en.'),
+                    '/', '.htaccess', 'en', '', '.htaccess', '.htaccess.en', '/.htaccess', '/.htaccess.en', nil, '.htaccess')
+    check_proc.call(Webgen::Path.new('/.htaccess.en.page'),
+                    '/', '.htaccess', 'en', 'page', '.htaccess.page', '.htaccess.en.page', '/.htaccess.page', '/.htaccess.en.page', nil, '.htaccess')
+
+    # Check fragment paths
+    assert_raises(RuntimeError) { Webgen::Path.new("/#hallo")}
+    assert_raises(RuntimeError) { Webgen::Path.new("/#hallo#done")}
+    check_proc.call(Webgen::Path.new('/file#hallo'),
+                    '/file', '#hallo', nil, '', '#hallo', '#hallo', '/file#hallo', '/file#hallo', nil, '#hallo')
+    check_proc.call(Webgen::Path.new('/file.en.page#hallo'),
+                    '/file.en.page', '#hallo', nil, '', '#hallo', '#hallo', '/file.page#hallo', '/file.en.page#hallo', nil, '#hallo')
+
+    # Check general exceptions
+    assert_raise(RuntimeError) { Webgen::Path.new('/no_basename#') }
+    assert_raise(RuntimeError) { Webgen::Path.new('relative.page') }
 
     path = Webgen::Path.new('/test/', '/other.path')
     assert_equal('/other.path', path.source_path)
     assert_equal('/test/', path.path)
+    assert_equal(false, path.passive?)
   end
 
   def test_mount_at
-    p = Webgen::Path.new('test.de.page')
-    p = p.mount_at('/somedir')
+    p = Webgen::Path.new('/test.de.page')
+    assert_raise(ArgumentError) { p.mount_at('no_start_slash/') }
+    assert_raise(ArgumentError) { p.mount_at('/no_end_slash') }
+    assert_raise(ArgumentError) { p.mount_at('/no_with_hash#_char/') }
+    assert_raise(ArgumentError) { p.mount_at('/', 'no_start_slash/') }
+    assert_raise(ArgumentError) { p.mount_at('/', '/no_end_slash') }
+    assert_raise(ArgumentError) { p.mount_at('/', '/no_with_hash#_char/') }
+
+    p = p.mount_at('/somedir/')
     assert_equal('/somedir/test.de.page', p.path)
     assert_equal('/somedir/test.de.page', p.source_path)
-    assert_equal('/somedir/', p.directory)
+    assert_equal('/somedir/', p.parent_path)
 
     p = Webgen::Path.new('/')
-    p = p.mount_at('/somedir')
+    p = p.mount_at('/somedir/')
     assert_equal('/somedir/', p.path)
     assert_equal('/somedir/', p.source_path)
-    assert_equal('/', p.directory)
-    assert_equal('somedir', p.cn)
+    assert_equal('/', p.parent_path)
+    assert_equal('somedir/', p.cn)
     assert_equal('Somedir', p.meta_info['title'])
 
     p = Webgen::Path.new('/source/test.rb')
     p = p.mount_at('/', '/source/')
     assert_equal('/test.rb', p.path)
     assert_equal('/test.rb', p.source_path)
-    assert_equal('/', p.directory)
+    assert_equal('/', p.parent_path)
     assert_equal('test.rb', p.cn)
     assert_equal('Test', p.meta_info['title'])
 
     p = Webgen::Path.new('/source/')
-    p = p.mount_at('/', '/source')
+    p = p.mount_at('/', '/source/')
     assert_equal('/', p.path)
     assert_equal('/', p.source_path)
-    assert_equal('/', p.directory)
+    assert_equal('', p.parent_path)
     assert_equal('/', p.cn)
     assert_equal('/', p.meta_info['title'])
 
@@ -82,53 +112,53 @@ class TestPath < Test::Unit::TestCase
     p = p.mount_at('/source/')
     assert_equal('/source/test.rb', p.path)
     assert_equal('/other.rb', p.source_path)
-    assert_equal('/source/', p.directory)
+    assert_equal('/source/', p.parent_path)
     assert_equal('test.rb', p.cn)
     assert_equal('Test', p.meta_info['title'])
   end
 
   def test_dup
-    p = Webgen::Path.new('test.de.page')
+    p = Webgen::Path.new('/test.de.page')
     dupped = p.dup
     dupped.meta_info['title'] = 'changed'
     assert_equal('Test', p.meta_info['title'])
   end
 
   def test_io
-    p = Webgen::Path.new('test.de.page')
+    p = Webgen::Path.new('/test.de.page')
     assert_raise(RuntimeError) { p.io }
-    p = Webgen::Path.new('test.de.page') { StringIO.new('hallo') }
+    p = Webgen::Path.new('/test.de.page') { StringIO.new('hallo') }
     assert_equal('hallo', p.io.data)
     assert_equal('hallo', p.io.stream {|f| f.read })
   end
 
-  def test_lcn
-    p = Webgen::Path.new('test.de.page')
-    assert_equal('test.page', p.cn)
-    assert_equal('test.de.page', p.lcn)
-    p = Webgen::Path.new('test.page')
-    assert_equal('test.page', p.cn)
-    assert_equal('test.page', p.lcn)
-  end
-
   def test_equality
-    p = Webgen::Path.new('test.de.page')
-    assert_equal('test.de.page', p)
-    assert_equal(Webgen::Path.new('test.de.page'), p)
+    p = Webgen::Path.new('/test.de.page')
+    assert_equal('/test.de.page', p)
+    assert_equal(Webgen::Path.new('/test.de.page'), p)
     assert_not_equal(5, p)
   end
 
-  def test_hashing
-    path = Webgen::Path.new('test.de.page')
-    h = { 'test.de.page' => :value }
-    assert_equal(:value, h['test.de.page'])
-    assert_equal(:value, h[path])
-    assert(path <=> 'test.de.page')
-    h = { p => :newvalue}
-    assert_nil(h['test.de.page'])
+  def test_comparison
+    p1 = Webgen::Path.new('/test.de.page')
+    p2 = Webgen::Path.new('/test.en.page')
+    assert_equal(0, p1 <=> p1)
+    assert_equal(-1, p1 <=> p2)
+    assert_equal(1, p2 <=> p1)
   end
 
-  def test_matching
+  # Problem with hashing under 1.8.6 when changing from 'test.de.page' to '/test.de.page'...
+  #   def test_hashing
+  #     path = Webgen::Path.new('test.de.page')
+  #     h = { 'test.de.page' => :value }
+  #     assert_equal(:value, h['test.de.page'])
+  #     assert_equal(:value, h[path])
+  #     assert(path <=> 'test.de.page')
+  #     h = { p => :newvalue}
+  #     assert_nil(h['test.de.page'])
+  #   end
+
+  def test_match
     path = '/dir/to/file.de.page'
     assert(Webgen::Path.match(path, '**/*'))
     assert(Webgen::Path.match(path, '**/file.de.PAGE'))
@@ -151,14 +181,25 @@ class TestPath < Test::Unit::TestCase
     assert(!Webgen::Path.match(path, '/'))
   end
 
+  def test_apath
+    assert_raise(ArgumentError) { Webgen::Path.make_absolute('test', 'test') }
+    assert_equal('/', Webgen::Path.make_absolute('/', '/'))
+    assert_equal('/dir', Webgen::Path.make_absolute('/other', '/dir'))
+    assert_equal('/other/dir', Webgen::Path.make_absolute('/other', 'dir'))
+    assert_equal('/test/dir', Webgen::Path.make_absolute('/other', '../test/dir'))
+    assert_equal('/', Webgen::Path.make_absolute('/', '/..'))
+    assert_equal('/dir', Webgen::Path.make_absolute('/', '/../dir/.'))
+  end
+
+
   def test_introspection
-    p = Webgen::Path.new('test.de.page')
-    assert_equal('test.de.page', p.to_s)
-    assert(p.inspect.include?('test.de.page'))
+    p = Webgen::Path.new('/test.de.page')
+    assert_equal('/test.de.page', p.to_s)
+    assert(p.inspect.include?('/test.de.page'))
   end
 
   def test_changed?
-    p = Webgen::Path.new('test.de.page')
+    p = Webgen::Path.new('/test.de.page')
     assert(p.changed?)
   end