thewoolleyman-webgen 0.5.8.20090419

data/test/helper.rb

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/blackboard'
+require 'webgen/website'
+
+module Test
+
+  module WebsiteHelper
+
+    def setup
+      super
+      @website = Webgen::Website.new('test', nil)
+      @website.init
+      Thread.current[:webgen_website] = @website
+    end
+
+    def teardown
+      Thread.current[:webgen_website] = nil
+    end
+
+    def path_with_meta_info(path, mi = {}, sh = nil, &block)
+      path = Webgen::Path.new(path, &block)
+      path.meta_info.update(@website.config['sourcehandler.default_meta_info'][:all].merge(mi))
+      path.meta_info.update((@website.config['sourcehandler.default_meta_info'][sh] || {}).merge(mi)) if sh
+      path
+    end
+
+    def create_sitemap_nodes
+      {
+        :root => root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/', {'index_path' => 'index.html'}),
+        :dir1 => dir1 = Webgen::Node.new(root, '/dir1/', 'dir1/'),
+        :file11_en => file11 = Webgen::Node.new(dir1, '/dir1/file11.en.html', 'file11.html', {'lang' => 'en', 'in_menu' => true, 'kind' => 'page'}),
+        :file11_en_f1 => file11_f1 = Webgen::Node.new(file11, '/dir1/file11.en.html#f1', '#f1', {'in_menu' => true}),
+        :dir2 => dir2 = Webgen::Node.new(root, '/dir2/', 'dir2/', {'kind' => 'directory'}),
+        :file21_en => Webgen::Node.new(dir2, '/dir2/file21.en.html', 'file21.html', {'lang' => 'en', 'in_menu' => false, 'kind' => 'other'}),
+        :file1_de => Webgen::Node.new(root, '/file1.de.html', 'file1.html', {'lang' => 'de', 'in_menu' => true, 'kind' => 'page'}),
+        :index_en => Webgen::Node.new(root, '/index.en.html', 'index.html', {'lang' => 'en', 'kind' => 'page'}),
+        :dir3 => dir3 = Webgen::Node.new(root, '/dir3/', 'dir3/', {'kind' => 'directory', 'index_path' => 'index.html'}),
+        :index3_en => Webgen::Node.new(dir3, '/dir3/index.en.html', 'index.html', {'lang' => 'en', 'kind' => 'page'})
+      }
+    end
+
+  end
+
+end

data/test/test_blackboard.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/blackboard'
+
+class TestBlackboard < Test::Unit::TestCase
+
+  def setup
+    @blackboard = Webgen::Blackboard.new
+  end
+
+  def test_add_listener
+    assert_raise(ArgumentError) { @blackboard.add_listener(:test, nil) }
+    assert_raise(ArgumentError) { @blackboard.add_listener(:test, 'not callable') }
+    @blackboard.add_listener([:test, :other], proc { throw :called })
+    assert_throws(:called) { @blackboard.dispatch_msg(:test) }
+    assert_throws(:called) { @blackboard.dispatch_msg(:other) }
+  end
+
+  def test_del_listener
+    listener = proc { throw :called }
+    @blackboard.add_listener(:test, listener)
+    assert_throws(:called) { @blackboard.dispatch_msg(:test) }
+    @blackboard.del_listener(:test, listener)
+    assert_nothing_thrown { @blackboard.dispatch_msg(:test) }
+  end
+
+  def test_dispatch_msg
+    listener = proc { throw :called }
+    @blackboard.add_listener(:test, listener)
+    assert_throws(:called) { @blackboard.dispatch_msg(:test) }
+  end
+
+  def test_add_service
+    assert_raise(ArgumentError) { @blackboard.add_service(:test, 'not callable') }
+    @blackboard.add_service(:test) { throw :called }
+    assert_raise(RuntimeError) { @blackboard.add_service(:test, nil) }
+  end
+
+  def test_del_service
+    @blackboard.add_service(:test) { throw :called }
+    assert_throws(:called) { @blackboard.invoke(:test) }
+    @blackboard.del_service(:test)
+    assert_raise(ArgumentError) { @blackboard.invoke(:test) }
+  end
+
+  def service
+    yield :test
+  end
+
+  def test_invoke
+    @blackboard.add_service(:test) { throw :called }
+    assert_throws(:called) { @blackboard.invoke(:test) }
+    assert_raise(ArgumentError) { @blackboard.invoke(:unknown) }
+
+    @blackboard.add_service(:other, method(:service))
+    assert_throws(:test) { @blackboard.invoke(:other) {|p| throw p}}
+  end
+
+end

data/test/test_cache.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems'
+require 'test/unit'
+require 'webgen/cache'
+
+class TestCache < Test::Unit::TestCase
+
+  def setup
+    @cache = Webgen::Cache.new
+  end
+
+  def dump_and_restore
+    data = @cache.dump
+    setup
+    @cache.restore(data)
+  end
+
+  def test_standard_cache
+    @cache[:key] = :value
+    assert_equal(:value, @cache[:key])
+    dump_and_restore
+    assert_equal(:value, @cache[:key])
+    @cache[:key] = :newvalue
+    assert_equal(:value, @cache[:key])
+    dump_and_restore
+    assert_equal(:newvalue, @cache[:key])
+  end
+
+  def test_permanent_cache
+    @cache.permanent[:key] = :value
+    assert_equal(:value, @cache.permanent[:key])
+    dump_and_restore
+    assert_equal(:value, @cache.permanent[:key])
+  end
+
+  def test_volatile_cache
+    @cache.volatile[:key] = :value
+    assert_equal(:value, @cache.volatile[:key])
+    dump_and_restore
+    assert_equal(nil, @cache.volatile[:key])
+
+    @cache.volatile[:key] = :value
+    obj = @cache.instance('Hash')
+    @cache.reset_volatile_cache
+    assert_equal(nil, @cache.volatile[:key])
+    assert_equal(obj, @cache.instance('Hash'))
+  end
+
+  def test_instance
+    obj = @cache.instance('Hash')
+    assert_kind_of(Hash, obj)
+    assert_equal(obj, @cache.instance('Hash'))
+    @cache.instance('Array')
+    assert_equal(['Hash', 'Array'], @cache.permanent[:classes])
+    dump_and_restore
+    assert_not_nil(@cache.volatile[:classes]['Hash'])
+  end
+
+end

data/test/test_cli.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/cli'
+
+class TestCLICommandParser < Test::Unit::TestCase
+
+  def test_initialize
+    cli = Webgen::CLI::CommandParser.new
+    assert_equal('render', cli.main_command.default_command)
+    assert_equal(:normal, cli.verbosity)
+    assert_equal(Logger::WARN, cli.log_level)
+    assert_equal(Dir.pwd, cli.directory)
+  end
+
+  def test_website_from_env
+    ENV['WEBGEN_WEBSITE'] = '/webgen/test/site'
+    cli = Webgen::CLI::CommandParser.new
+    assert_equal('/webgen/test/site', cli.directory)
+  end
+end

data/test/test_common.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/common'
+
+class TestCommon < Test::Unit::TestCase
+
+  def test_absolute_path
+    assert_raise(ArgumentError) { Webgen::Common.absolute_path('test', 'test') }
+    assert_equal('/', Webgen::Common.absolute_path('/', '/'))
+    assert_equal('/dir', Webgen::Common.absolute_path('/dir', '/other'))
+    assert_equal('/other/dir', Webgen::Common.absolute_path('dir', '/other'))
+    assert_equal('/test/dir', Webgen::Common.absolute_path('../test/dir', '/other'))
+    assert_equal('/', Webgen::Common.absolute_path('/..', '/'))
+    assert_equal('/dir', Webgen::Common.absolute_path('/../dir/.', '/'))
+  end
+
+end

data/test/test_common_sitemap.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/common'
+
+class TestCommonSitemap < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Common::Sitemap.new
+    @nodes = create_sitemap_nodes
+  end
+
+  def do_assert(node, lang, honor_in_menu, any_lang, used_kinds, result)
+    assert_equal(result.map {|name| @nodes[name].absolute_lcn },
+                 @obj.create_sitemap(node, lang, {
+                                       'common.sitemap.honor_in_menu' => honor_in_menu,
+                                       'common.sitemap.any_lang' => any_lang,
+                                       'common.sitemap.used_kinds' => used_kinds
+                                     }).to_lcn_list.flatten)
+  end
+
+  def test_create_sitemap_and_node_chagned
+    do_assert(@nodes[:file11_en], 'en', false, false, ['page'],
+              [:dir1, :file11_en, :index_en, :dir3])
+    do_assert(@nodes[:file11_en], 'en', true, false, ['page'],
+              [:dir1, :file11_en])
+    do_assert(@nodes[:file11_en], 'en', false, false, ['page', 'other'],
+              [:dir1, :file11_en, :dir2, :file21_en, :index_en, :dir3])
+    do_assert(@nodes[:file11_en], 'en', false, false, [],
+              [:dir1, :file11_en, :file11_en_f1, :dir2, :file21_en, :index_en, :dir3])
+    do_assert(@nodes[:file11_en], 'en', false, false, ['noone'],
+              [])
+    do_assert(@nodes[:file11_en], 'en', false, false, ['page', 'directory'],
+              [:dir1, :file11_en, :dir2, :index_en, :dir3])
+    do_assert(@nodes[:file11_en], 'en', true, false, ['page', 'directory'],
+              [:dir1, :file11_en])
+
+    do_assert(@nodes[:file1_de], 'de', false, false, ['page'],
+              [:file1_de])
+    do_assert(@nodes[:file1_de], 'de', false, true, ['page'],
+              [:dir1, :file11_en, :file1_de, :index_en, :dir3, :index3_en])
+
+    @nodes[:file11_en].unflag(:dirty)
+    @website.blackboard.dispatch_msg(:node_changed?, @nodes[:file11_en])
+    assert(!@nodes[:file11_en].flagged(:dirty))
+
+    @nodes[:file11_en].flag(:dirty_meta_info)
+    @website.blackboard.dispatch_msg(:node_changed?, @nodes[:file11_en])
+    assert(@nodes[:file11_en].flagged(:dirty))
+  end
+
+end

data/test/test_configuration.rb

@@ -0,0 +1,68 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/configuration'
+require 'webgen/sourcehandler'
+
+class TestConfiguration < Test::Unit::TestCase
+
+  def test_defining_options
+    @config = Webgen::Configuration.new
+    @config.test.value(:value, :opts => true)
+    assert_equal(:value, @config['test.value'])
+    assert_equal({:opts => true}, @config.meta_info['test.value'])
+    @config.test.value(:other_value, :doc => true)
+    assert_equal(:value, @config['test.value'])
+    assert_equal({:opts => true, :doc => true}, @config.meta_info['test.value'])
+    @config.test.other(:value)
+    assert_equal({}, @config.meta_info['test.other'])
+  end
+
+  def test_get_options
+    @config = Webgen::Configuration.new
+    @config.test.value(:value)
+    assert_equal(:value, @config['test.value'])
+    assert_raise(ArgumentError) { @config['not.existing']}
+  end
+
+  def test_set_options
+    @config = Webgen::Configuration.new
+    @config.test.value(:value)
+    assert_equal(:value, @config['test.value'])
+    @config['test.value'] = :newvalue
+    assert_equal(:newvalue, @config['test.value'])
+
+    assert_raise(ArgumentError) { @config['not.existing'] = :newvalue}
+  end
+
+  def test_set_options_using_helpers
+    @config = Webgen::Configuration.new
+    @config.sourcehandler.default_meta_info({'Webgen::SourceHandler::Page' => {'in_menu' => true}})
+    @config.sourcehandler.patterns({'Webgen::SourceHandler::Page' => ['**/*.page']})
+
+    @config.default_meta_info('Page' => {'in_menu' => false, 'test' => true})
+    assert_equal({'in_menu' => false, 'test' => true}, @config['sourcehandler.default_meta_info']['Webgen::SourceHandler::Page'])
+    @config.default_meta_info('Webgen::SourceHandler::Page' => {'in_menu' => true, :action => 'replace'})
+    assert_equal({'in_menu' => true}, @config['sourcehandler.default_meta_info']['Webgen::SourceHandler::Page'])
+    @config.default_meta_info('Other' => {'in_menu' => false})
+    assert_equal({'in_menu' => false}, @config['sourcehandler.default_meta_info']['Other'])
+    assert_raise(ArgumentError) { @config.default_meta_info([5,6]) }
+
+    @config.patterns('Page' => ['**/*.html'])
+    assert_equal(['**/*.html'], @config['sourcehandler.patterns']['Webgen::SourceHandler::Page'])
+    @config.patterns('Page' => {'del' => ['**/*.html'], 'add' => ['**/*.page']})
+    assert_equal(['**/*.page'], @config['sourcehandler.patterns']['Webgen::SourceHandler::Page'])
+    @config.patterns('Other' => {'del' => ['**/*.html'], 'add' => ['**/*.page']})
+    assert_equal(['**/*.page'], @config['sourcehandler.patterns']['Other'])
+    assert_raise(ArgumentError) { @config.patterns([5,6]) }
+    assert_raise(ArgumentError) { @config.patterns('Page' => 5) }
+
+    @config.default_processing_pipeline('Page' => 'tags,maruku')
+    assert_equal('tags,maruku', @config['sourcehandler.default_meta_info']['Webgen::SourceHandler::Page']['blocks']['default']['pipeline'])
+    @config.default_processing_pipeline('Other' => 'tags,maruku')
+    assert_equal('tags,maruku', @config['sourcehandler.default_meta_info']['Other']['blocks']['default']['pipeline'])
+    assert_raise(ArgumentError) { @config.default_processing_pipeline([5,6]) }
+    assert_raise(ArgumentError) { @config.default_processing_pipeline('Page' => [5,6]) }
+  end
+
+end

data/test/test_contentprocessor.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/contentprocessor'
+
+class TestContentProcessor < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @website.config.data['contentprocessor.map'] = {'test' => Hash}
+  end
+
+  def test_access_hash
+    ah = Webgen::ContentProcessor::AccessHash.new
+    assert(ah.has_key?('test'))
+    assert(!ah.has_key?('other'))
+    assert_kind_of(Hash, ah['test'])
+    assert_nil(ah['other'])
+  end
+
+  def test_list
+    assert_equal(['test'], Webgen::ContentProcessor.list)
+  end
+
+  def test_for_name
+    assert_kind_of(Hash, Webgen::ContentProcessor.for_name('test'))
+    assert_nil(Webgen::ContentProcessor.for_name('other'))
+  end
+
+end

data/test/test_contentprocessor_blocks.rb

@@ -0,0 +1,68 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/page'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorBlocks < Test::Unit::TestCase
+
+  def test_process
+    obj = Webgen::ContentProcessor::Blocks.new
+    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")
+    template = Webgen::Node.new(root, 'template', 'template')
+    template.node_info[:page] = Webgen::Page.from_data("--- name:content pipeline:blocks\nbefore<webgen:block name='content' />after")
+    processors = { 'blocks' => obj }
+
+    context = Webgen::ContentProcessor::Context.new(:chain => [node], :processors => processors)
+    context.content = '<webgen:block name="content" /><webgen:block name="content" chain="template;test" />'
+    obj.call(context)
+    assert_equal('databeforedataafter', context.content)
+    assert_equal(Set.new([node.absolute_lcn, template.absolute_lcn]), node.node_info[:used_nodes])
+
+    context.content = '<webgen:block name="content" node="next" /><webgen:block name="content" chain="template;test" />'
+    obj.call(context)
+    assert_equal('databeforedataafter', context.content)
+
+    context.content = '<webgen:block name="nothing"/>'
+    assert_raise(RuntimeError) { obj.call(context) }
+
+    context.content = '<webgen:block name="content" chain="invalid" /><webgen:block name="content" />'
+    node.node_info[:used_nodes] = Set.new
+    context[:chain] = [node, template, node]
+    obj.call(context)
+    assert_equal('<webgen:block name="content" chain="invalid" />beforedataafter', context.content)
+    assert_equal(Set.new([template.absolute_lcn, node.absolute_lcn]), node.node_info[:used_nodes])
+
+    context.content = 'bef<webgen:block name="other" chain="template;test" notfound="ignore" />aft'
+    obj.call(context)
+    assert_equal('befaft', context.content)
+
+    context.content = '<webgen:block name="other" chain="template" node="first" />'
+    assert_raise(RuntimeError) { obj.call(context) }
+
+    context.content = '<webgen:block name="other" chain="template;test" node="first" />'
+    obj.call(context)
+    assert_equal('other', context.content)
+
+    context.content = '<webgen:block name="other" chain="test" node="first" />'
+    obj.call(context)
+    assert_equal('other', context.content)
+
+    context.content = '<webgen:block name="invalid" node="first" notfound="ignore" /><webgen:block name="content" />'
+    obj.call(context)
+    assert_equal('beforedataafter', context.content)
+
+    context[:chain] = [node, template]
+    context.content = '<webgen:block name="other" node="current" />'
+    obj.call(context)
+    assert_equal('other', context.content)
+
+    context.content = '<webgen:block name="other" node="current" chain="template"/>'
+    obj.call(context)
+    assert_equal('other', context.content)
+  end
+
+end

data/test/test_contentprocessor_builder.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorBuilder < Test::Unit::TestCase
+
+  def test_call
+    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 => node.absolute_lcn) { xml.strong('test'); " +
+      "website; context; ref_node; dest_node }"
+    context = Webgen::ContentProcessor::Context.new(:content => content,
+                                                    :chain => [node])
+    assert_equal("<div path=\"/test\">\n  <strong>test</strong>\n</div>\n", obj.call(context).content)
+
+    context.content = 'raise "bla"'
+    assert_raise(RuntimeError) { obj.call(context).content }
+  end
+
+end