webgen 0.5.5 → 0.5.6

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_contentprocessor_redcloth.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require 'webgen/websiteaccess'
 require 'webgen/contentprocessor'
 
 class TestContentProcessorRedCloth < Test::Unit::TestCase

data/test/test_contentprocessor_tags.rb

@@ -1,7 +1,7 @@
 require 'test/unit'
 require 'helper'
 require 'webgen/tree'
-require 'webgen/contentprocessor/tags'
+require 'webgen/contentprocessor'
 
 class TestContentProcessorTags < Test::Unit::TestCase
 

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

@@ -31,7 +31,7 @@ class TestNode < Test::Unit::TestCase
     }
   end
 
-  def test_initialize
+  def test_initialize_and_reinit
     check_proc = proc do |node, parent, path, cn, lcn, alcn, lang, mi|
       assert_equal(parent, node.parent)
       assert_equal(path, node.path)
@@ -39,8 +39,9 @@ class TestNode < Test::Unit::TestCase
       assert_equal(lcn, node.lcn)
       assert_equal(alcn, node.absolute_lcn)
       assert_equal(lang, node.lang)
-      assert(node.dirty)
-      assert(node.created)
+      assert_kind_of(Webgen::Language, node.lang) if node.lang
+      assert(node.flagged(:dirty))
+      assert(node.flagged(:created))
       assert_equal(mi, node.meta_info)
       assert_equal({:used_nodes => Set.new, :used_meta_info_nodes => Set.new}, node.node_info)
       mi.each {|k,v| assert_equal(v, node[k])}
@@ -55,9 +56,13 @@ class TestNode < Test::Unit::TestCase
 
     ['http://webgen.rubyforge.org', 'c:\\test'].each_with_index do |abspath, index|
       cn = 'test' + index.to_s + '.html'
-      child = Webgen::Node.new(node, abspath, cn)
-      check_proc.call(child, node, abspath, cn, cn, '/test/' + cn, nil, {})
+      c = Webgen::Node.new(node, abspath, cn)
+      check_proc.call(c, node, abspath, cn, cn, '/test/' + 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'})
   end
 
   def test_type_checkers
@@ -77,6 +82,22 @@ class TestNode < Test::Unit::TestCase
     assert_equal(:value, node[:other])
   end
 
+  def test_flags
+    node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
+    assert(node.flagged(:created))
+    assert(node.flagged(:dirty))
+    node.unflag(:dirty)
+    assert(!node.flagged(:dirty))
+    node.flag(:a, :b, :c)
+    assert(node.flagged(:a))
+    assert(node.flagged(:b))
+    assert(node.flagged(:c))
+    node.unflag(:a, :b, :c)
+    assert(!node.flagged(:a))
+    assert(!node.flagged(:b))
+    assert(!node.flagged(:c))
+  end
+
   def test_in_lang
     nodes = create_default_nodes
 
@@ -143,16 +164,16 @@ class TestNode < Test::Unit::TestCase
 
   def test_changed
     node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})
-    node.dirty = node.created = false
+    node.unflag(:dirty, :created)
 
     calls = 0
-    @website.blackboard.add_listener(:node_changed?) {|n| assert(node, n); node.dirty = true; calls += 1}
+    @website.blackboard.add_listener(:node_changed?) {|n| assert(node, n); node.flag(:dirty); calls += 1}
     node.changed?
     assert_equal(1, calls)
     node.changed?
     assert_equal(1, calls)
 
-    node.dirty = false
+    node.unflag(:dirty)
     node.node_info[:used_nodes] << node.absolute_lcn
     node.node_info[:used_nodes] << 'unknown alcn'
     node.node_info[:used_nodes] << @tree.dummy_root.absolute_lcn
@@ -161,8 +182,8 @@ class TestNode < Test::Unit::TestCase
 
     # Test circular depdendence
     other_node = Webgen::Node.new(@tree.dummy_root, '/other', 'test.l', {'lang' => 'de', :test => :value})
-    other_node.dirty = node.created = false
-    node.dirty = false
+    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]
     node.changed?
@@ -170,21 +191,20 @@ class TestNode < Test::Unit::TestCase
 
   def test_meta_info_changed
     node = Webgen::Node.new(@tree.dummy_root, '/', '/')
-    node.dirty = node.created = false
+    node.unflag(:dirty, :created)
 
     calls = 0
-    @website.blackboard.add_listener(:node_meta_info_changed?) {|n| assert(node, n); node.dirty_meta_info = true; calls += 1}
+    @website.blackboard.add_listener(:node_meta_info_changed?) {|n| assert(node, n); node.flag(:dirty_meta_info); calls += 1}
     assert(node.meta_info_changed?)
     assert_equal(1, calls)
     assert(node.meta_info_changed?)
     assert_equal(1, calls)
 
-    node.dirty_meta_info = false
+    node.unflag(:dirty_meta_info)
     node.node_info[:used_meta_info_nodes] << node.absolute_lcn
     node.node_info[:used_meta_info_nodes] << 'unknown alcn'
-    node.node_info[:used_meta_info_nodes] << @tree.dummy_root.absolute_lcn
     assert(node.meta_info_changed?)
-    assert_equal(2, calls)
+    assert_equal(1, calls)
   end
 
   def test_method_missing

data/test/test_output_filesystem.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'helper'
-require 'webgen/output/filesystem'
+require 'webgen/output'
 require 'tmpdir'
 require 'fileutils'
 

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: |
@@ -118,7 +118,7 @@ class TestPage < Test::Unit::TestCase
       content: "content\\n----------- some block start???\\nthings"
 EOF
 
-  INVALID=<<EOF
+  INVALID_MI=<<EOF
 # invalid meta info: none specified
 - "---\\n---"
 
@@ -136,7 +136,9 @@ EOF
   : * [ }
   ---
   asdf kadsfakl
+EOF
 
+  INVALID_BLOCKS=<<EOF
 # two blocks with same name
 - |
   aasdf
@@ -155,16 +157,23 @@ EOF
 EOF
 
   def test_invalid_pagefiles
-    testdata = YAML::load(INVALID)
+    testdata = YAML::load(INVALID_MI)
+    testdata.each_with_index do |data, index|
+      assert_raise(Webgen::WebgenPageFormatError, "test mi item #{index}") { Webgen::Page.from_data(data) }
+      assert_raise(Webgen::WebgenPageFormatError, "test mi item #{index}") { Webgen::Page.meta_info_from_data(data) }
+    end
+    testdata = YAML::load(INVALID_BLOCKS)
     testdata.each_with_index do |data, index|
-      assert_raise(Webgen::WebgenPageFormatError, "test item #{index}") { Webgen::Page.from_data(data) }
+      assert_raise(Webgen::WebgenPageFormatError, "test blocks item #{index}") { Webgen::Page.from_data(data) }
     end
   end
 
   def test_valid_pagefiles
     YAML::load(VALID).each_with_index do |data, oindex|
+      mi = Webgen::Page.meta_info_from_data(data['in'])
+      assert_equal(data['meta_info'], mi, "test item #{oindex} - meta info directly")
       d = Webgen::Page.from_data(data['in'])
-      assert_equal(data['meta_info'], d.meta_info, "test item #{oindex} - meta info")
+      assert_equal(data['meta_info'], d.meta_info, "test item #{oindex} - meta info all")
       assert_equal(data['blocks'].length*2, d.blocks.length)
       data['blocks'].each_with_index do |b, index|
         index += 1

data/test/test_path.rb

@@ -7,6 +7,7 @@ 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)
       assert_equal(lang, o.meta_info['lang'])
@@ -38,17 +39,23 @@ class TestPath < Test::Unit::TestCase
                     '/', '/', '/', nil, '', '/', nil, '/')
     check_proc.call(Webgen::Path.new('/dir/'),
                     '/dir/', '/', 'dir', nil, '', 'dir', nil, 'Dir')
+
+    path = Webgen::Path.new('/test/', '/other.path')
+    assert_equal('/other.path', path.source_path)
+    assert_equal('/test/', path.path)
   end
 
   def test_mount_at
     p = Webgen::Path.new('test.de.page')
     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)
 
     p = Webgen::Path.new('/')
     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('Somedir', p.meta_info['title'])
@@ -56,6 +63,7 @@ class TestPath < Test::Unit::TestCase
     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('test.rb', p.cn)
     assert_equal('Test', p.meta_info['title'])
@@ -63,9 +71,18 @@ class TestPath < Test::Unit::TestCase
     p = Webgen::Path.new('/source/')
     p = p.mount_at('/', '/source')
     assert_equal('/', p.path)
+    assert_equal('/', p.source_path)
     assert_equal('/', p.directory)
     assert_equal('/', p.cn)
     assert_equal('/', p.meta_info['title'])
+
+    p = Webgen::Path.new('/test.rb', '/other.rb')
+    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('test.rb', p.cn)
+    assert_equal('Test', p.meta_info['title'])
   end
 
   def test_dup
@@ -110,11 +127,26 @@ class TestPath < Test::Unit::TestCase
   end
 
   def test_matching
-    path = Webgen::Path.new('/dir/to/file.de.page')
-    assert(path =~ '**/*')
-    assert(path =~ '**/file.de.PAGE')
-    assert(path =~ '/dir/*/file.*.page')
-    assert(path !~ '**/*.test')
+    path = '/dir/to/file.de.page'
+    assert(Webgen::Path.match(path, '**/*'))
+    assert(Webgen::Path.match(path, '**/file.de.PAGE'))
+    assert(Webgen::Path.match(path, '/dir/*/file.*.page'))
+    assert(!Webgen::Path.match(path, '**/*.test'))
+
+    path = '/dir/'
+    assert(Webgen::Path.match(path, '/dir/'))
+    assert(Webgen::Path.match(path, '/dir'))
+
+    path = '/dir'
+    assert(Webgen::Path.match(path, '/dir/'))
+    assert(Webgen::Path.match(path, '/dir'))
+
+    path = '/'
+    assert(Webgen::Path.match(path, '/'))
+    assert(!Webgen::Path.match(path, ''))
+
+    path = ''
+    assert(!Webgen::Path.match(path, '/'))
   end
 
   def test_introspection

data/test/test_source_filesystem.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'helper'
-require 'webgen/source/filesystem'
+require 'webgen/source'
 
 class TestSourceFileSystemPath < Test::Unit::TestCase
 

data/test/test_source_stacked.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'helper'
-require 'webgen/source/stacked'
+require 'webgen/source'
 
 class TestSourceFileSystemStacked < Test::Unit::TestCase
 

data/test/test_sourcehandler_base.rb

@@ -3,11 +3,13 @@ require 'helper'
 require 'webgen/tree'
 require 'webgen/node'
 require 'webgen/path'
-require 'webgen/sourcehandler/base'
+require 'webgen/sourcehandler'
 require 'time'
 
 class TestSourceHandlerBase < Test::Unit::TestCase
 
+  class TestSH; include Webgen::SourceHandler::Base; end
+
   include Test::WebsiteHelper
 
   def setup
@@ -16,6 +18,33 @@ class TestSourceHandlerBase < Test::Unit::TestCase
     @obj.extend(Webgen::SourceHandler::Base)
   end
 
+  def test_create_node
+    tree = Webgen::Tree.new
+    path = path_with_meta_info('/path.html')
+    count = 0
+
+    path.instance_eval { @source_path = '/path'}
+    node = @obj.create_node(tree.dummy_root, path) {|n| count +=1 }
+    assert_equal('/path', node.node_info[:src])
+    assert_equal('Object', node.node_info[:processor])
+    assert_kind_of(Time, node['modified_at'])
+    assert_equal(1, count)
+
+    other_node = @obj.create_node(tree.dummy_root, path) {|n| count +=1 }
+    assert_equal(node, other_node)
+    assert_equal(1, count)
+
+    node.flag(:reinit)
+    other_node = @obj.create_node(tree.dummy_root, path) {|n| count +=1 }
+    assert_equal(node, other_node)
+    assert_equal(2, count)
+
+    path.instance_eval { @source_path = '/other' }
+    other_node = @obj.create_node(tree.dummy_root, path) {|n| count +=1 }
+    assert_equal(node, other_node)
+    assert_equal(2, count)
+  end
+
   def test_node_exists
     @tree = Webgen::Tree.new
     node = Webgen::Node.new(@tree.dummy_root, 'test/', 'test', {'lang' => 'de', :test => :value})

data/test/test_sourcehandler_copy.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'helper'
-require 'webgen/sourcehandler/copy'
+require 'webgen/sourcehandler'
 require 'stringio'
 
 class TestSourceHandlerCopy < Test::Unit::TestCase