gettalong-webgen 0.5.4.20080929

data/test/helper.rb

@@ -0,0 +1,41 @@
+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'}),
+      }
+    end
+
+  end
+
+end

data/test/test_blackboard.rb

@@ -0,0 +1,58 @@
+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,57 @@
+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_common_sitemap.rb

@@ -0,0 +1,56 @@
+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])
+    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])
+    do_assert(@nodes[:file11_en], 'en', false, false, [],
+              [:dir1, :file11_en, :file11_en_f1, :dir2, :file21_en, :index_en])
+    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])
+    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])
+
+    @nodes[:file11_en].dirty = false
+    @website.blackboard.dispatch_msg(:node_changed?, @nodes[:file11_en])
+    assert(!@nodes[:file11_en].dirty)
+
+    @nodes[:file11_en].dirty_meta_info = true
+    @website.blackboard.dispatch_msg(:node_changed?, @nodes[:file11_en])
+    assert(@nodes[:file11_en].dirty)
+  end
+
+end

data/test/test_configuration.rb

@@ -0,0 +1,66 @@
+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,31 @@
+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,34 @@
+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")
+    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="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])
+  end
+
+end

data/test/test_contentprocessor_builder.rb

@@ -0,0 +1,19 @@
+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')
+    context = Webgen::ContentProcessor::Context.new(:content => "xml.div(:path => node.absolute_lcn) { xml.strong('test') }",
+                                                    :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

data/test/test_contentprocessor_context.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'helper'
+require 'webgen/contentprocessor/context'
+
+class TestContentProcessorContext < Test::Unit::TestCase
+
+  def setup
+    @context = Webgen::ContentProcessor::Context.new(:content => 'test', :key => :value, :chain => [:first, :last])
+  end
+
+  def test_initialize
+    context = Webgen::ContentProcessor::Context.new
+    assert_equal('', context.content)
+    assert_kind_of(Webgen::ContentProcessor::AccessHash, context[:processors])
+  end
+
+  def test_clone
+    other = @context.clone(:content => 'new', :key => :other)
+    assert_equal('new', other.content)
+    assert_equal(:other, other[:key])
+    assert_equal([:first, :last], other[:chain])
+  end
+
+  def test_accessors
+    assert_equal(:value, @context[:key])
+    assert_equal([:first, :last], @context[:chain])
+    assert_equal('test', @context.content)
+    assert_equal(:first, @context.ref_node)
+    assert_equal(:last, @context.content_node)
+    assert_equal(:value, @context[:key])
+    @context[:key] = :newvalue
+    assert_equal(:newvalue, @context[:key])
+    assert_equal(:last, @context.dest_node)
+    @context[:dest_node] = :other
+    assert_equal(:other, @context.dest_node)
+  end
+
+end

data/test/test_contentprocessor_erb.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorErb < Test::Unit::TestCase
+
+  def test_call
+    obj = Webgen::ContentProcessor::Erb.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => '<%= context[:doit] %>6', :doit => 'hallo',
+                                                    :chain => [node])
+    obj.call(context)
+    assert_equal('hallo6', context.content)
+
+    context.content = '<%= 5* %>'
+    assert_raise(RuntimeError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_erubis.rb

@@ -0,0 +1,47 @@
+require 'ostruct'
+require 'helper'
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/page'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorErubis < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_call
+    obj = Webgen::ContentProcessor::Erubis.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:doit => 'hallo', :chain => [node])
+
+    context.content = '<%= context[:doit] %>6'
+    assert_equal('hallo6', obj.call(context).content)
+
+    context.content = '<%= 5* %>'
+    assert_raise(RuntimeError) { obj.call(context) }
+
+    context.content = "<% for i in [1] %>\n<%= i %>\n<% end %>"
+    assert_equal("1\n", obj.call(context).content)
+    @website.config['contentprocessor.erubis.options'][:trim] = false
+    context.content = "<% for i in [1] %>\n<%== i %>\n<% end %>"
+    assert_equal("\n1\n", obj.call(context).content)
+
+    context[:block] = OpenStruct.new
+    context[:block].options = {'erubis_trim' => true}
+    context.content = "<% for i in [1] %>\n<%== i %>\n<% end %>"
+    assert_equal("1\n", obj.call(context).content)
+    context[:block].options['erubis_use_pi'] = true
+    context.content = "<?rb for i in [1] ?>\n@{i}@\n<?rb end ?>"
+    assert_equal("1\n", obj.call(context).content)
+    context[:block] = nil
+
+    @website.config['contentprocessor.erubis.use_pi'] = true
+    context.content = "<?rb for i in [1] ?>\n@{i}@\n<?rb end ?>"
+    assert_equal("1\n", obj.call(context).content)
+
+    page = Webgen::Page.from_data("--- pipeline:erubis erubis_trim:false erubis_use_pi:false\n<% for i in [1] %>\n<%== i %>\n<% end %>")
+    assert_equal("\n1\n", page.blocks['content'].render(context).content)
+  end
+
+end