thewoolleyman-webgen 0.5.8.20090419

data/test/test_tag_metainfo.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag'
+
+class TestTagMetainfo < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::Tag::Metainfo.new
+    node = Webgen::Node.new(Webgen::Tree.new.dummy_root, 'hallo.page', 'hallo.page', 'test' => 10, 'lang' => 'en')
+    c = Webgen::ContentProcessor::Context.new(:chain => [node])
+    assert_equal('', @obj.call('invalid', '', c))
+    assert_equal('10', @obj.call('test', '', c))
+    assert_equal('en', @obj.call('lang', '', c))
+  end
+
+end

data/test/test_tag_relocatable.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag'
+
+class TestTagRelocatable < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::Relocatable.new
+  end
+
+  def call(context)
+    @obj.call('relocatable', '', context)
+  end
+
+  def test_call
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, '/file.html', 'file.html', {'lang' => 'en'})
+    dir = Webgen::Node.new(root, '/dir/', 'dir/', 'index_path' => "index.html")
+    file = Webgen::Node.new(dir, '/dir/file.html', 'file.html', {'lang' => 'en'})
+    Webgen::Node.new(dir, '/dir/other.de.html', 'other.html', {'lang' => 'de'})
+    Webgen::Node.new(file, '/dir/file.html#fragment', '#fragment')
+    dir2 = Webgen::Node.new(root, '/dir2/', 'dir2/', 'index_path' => "index.html")
+    Webgen::Node.new(dir2, '/dir2/index.html', 'index.html')
+
+    context = Webgen::ContentProcessor::Context.new(:chain => [node])
+
+    # basic node resolving
+    @obj.set_params('tag.relocatable.path' => 'dir/file.html')
+    assert_equal('dir/file.html', call(context))
+    @obj.set_params('tag.relocatable.path' => 'dir/other.html')
+    assert_equal('', call(context))
+
+    # non-existing fragments
+    @obj.set_params('tag.relocatable.path' => 'file.html#hallo')
+    assert_equal('', call(context))
+
+    # absolute paths
+    @obj.set_params('tag.relocatable.path' => 'http://test.com')
+    assert_equal('http://test.com', call(context))
+
+    # directory paths
+    @obj.set_params('tag.relocatable.path' => 'dir')
+    assert_equal('dir/', call(context))
+    @obj.set_params('tag.relocatable.path' => 'dir2')
+    assert_equal('dir2/index.html', call(context))
+
+    # invalid paths
+    @obj.set_params('tag.relocatable.path' => ':/asdf=-)')
+    assert_equal('', call(context))
+  end
+
+end

data/test/test_tag_sitemap.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+require 'webgen/tag'
+
+class TestTagSitemap < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::Sitemap.new
+  end
+
+  def call(context, honor_in_menu, any_lang, used_kinds)
+    @obj.set_params({'common.sitemap.honor_in_menu' => honor_in_menu,
+                      'common.sitemap.any_lang' => any_lang,
+                      'common.sitemap.used_kinds' => used_kinds})
+    result = @obj.call('sitemap', '', context)
+    @obj.set_params({})
+    result
+  end
+
+  def test_call
+    nodes = create_sitemap_nodes
+    context = Webgen::ContentProcessor::Context.new(:chain => [nodes[:file11_en]])
+
+    assert_equal("<ul><li><a href=\"./\"></a>" +
+                 "<ul><li><span></span>"+
+                 "<ul><li><a href=\"#f1\"></a></li></ul></li></ul></li>" +
+                 "<li><a href=\"../dir2/\"></a>" +
+                 "<ul><li><a href=\"../dir2/file21.en.html\"></a></li></ul></li>"+
+                 "<li><a href=\"../index.en.html\"></a></li>" +
+                 "<li><a href=\"../dir3/index.en.html\"></a></li></ul>",
+                 call(context, false, false, []))
+    assert_equal("",
+                 call(context, false, false, ['noone']))
+  end
+
+  def test_tag_config_base
+    assert_equal('common.sitemap', @obj.send(:tag_config_base))
+  end
+
+end

data/test/test_tag_tikz.rb

@@ -0,0 +1,69 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tag'
+
+class TestTagTikZ < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @obj = Webgen::Tag::TikZ.new
+    Webgen::SourceHandler::Main.new # service create_nodes
+    Webgen::SourceHandler::Directory.new # service create_directories
+  end
+
+  def call(context, body, path, libs, opts, res, trans, imgattr)
+    @obj.set_params({'tag.tikz.path' => path, 'tag.tikz.libraries' => libs,
+                      'tag.tikz.opts' => opts, 'tag.tikz.resolution' => res,
+                      'tag.tikz.transparent' => trans, 'tag.tikz.img_attr' => imgattr})
+    result = @obj.call('tikz', body, context)
+    @obj.set_params({})
+    result
+  end
+
+  def test_call
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, '/file.html', 'file.page')
+    context = Webgen::ContentProcessor::Context.new(:chain => [node])
+
+    output = call(context, '\tikz \draw (0,0) -- (0,1);', 'test.png', [], '', '72 72', false, {})
+    assert_equal('<img src="test.png" />', output)
+    assert(root.tree['/test.png'])
+    assert_not_nil(root.tree['/test.png'].content)
+    root.tree.delete_node('/test.png')
+
+    output = call(context, '\tikz \asdfasdfasf', 'test.png', [], '', '72 72', false, {})
+    assert_equal('<img src="test.png" />', output)
+    assert(root.tree['/test.png'])
+    assert_nil(root.tree['/test.png'].content)
+    root.tree.delete_node('/test.png')
+
+    output = call(context, '\tikz \draw (0,0) -- (0,1);', '/images/test.gif', ['arrows'], '->', '72 72', true, {'alt' => 'title'})
+    assert_equal('<img src="images/test.gif" alt="title" />', output)
+    assert(root.tree['/images/test.gif'])
+    assert_not_nil(root.tree['/images/test.gif'].content)
+    root.tree.delete_node('/images/test.gif')
+
+    output = call(context, '\tikz \draw (0,0) -- (0,1);', 'images/../img/test.png', [], '', '300 72', true, {})
+    assert_equal('<img src="img/test.png" />', output)
+    assert(root.tree['/img/test.png'])
+    assert_not_nil(root.tree['/img/test.png'].content)
+    root.tree.delete_node('/img/test.png')
+  end
+
+  def test_run_command
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    context = Webgen::ContentProcessor::Context.new(:chain => [root])
+    assert_equal("hallo\n", @obj.send(:run_command, echo_cmd('hallo'), context))
+    assert_nil(@obj.send(:run_command, 'unknown_command 2>&1', context))
+  end
+
+  def echo_cmd(data)
+    (Config::CONFIG['arch'].include?('mswin32') ?  "echo #{data}" : "echo '#{data}'")
+  end
+
+
+end

data/test/test_tree.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+
+class TestTree < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @tree = Webgen::Tree.new
+  end
+
+  def test_initialize
+    assert_not_nil(@tree.dummy_root)
+    assert_equal('', @tree.dummy_root.absolute_lcn)
+  end
+
+  def test_root
+    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    assert_equal(root, @tree.root)
+    assert_equal('/', root.absolute_lcn)
+  end
+
+  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])
+    assert_equal(node, @tree['dummy/', :path])
+    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
+    nrcalls = 0
+    @website.blackboard.add_listener(:before_node_deleted) { nrcalls += 1 }
+
+    root = Webgen::Node.new(@tree.dummy_root, '/', '/')
+    file = Webgen::Node.new(root, 'testfile', 'testfile')
+    dir = Webgen::Node.new(root, 'testdir/', 'testdir')
+
+    @tree.delete_node(@tree.dummy_root)
+    assert_not_nil(@tree[''])
+
+    assert_nothing_raised { @tree.delete_node('/unknown_path') }
+
+    @tree.delete_node(file)
+    assert_nil(@tree['/testfile'])
+    assert_nil(@tree['/testfile', :acn])
+    assert_nil(@tree.node_info['/testfile'])
+    assert_equal(1, root.children.size)
+    assert_equal(1, nrcalls)
+
+    @tree.delete_node('/')
+    assert_nil(@tree['/testdir'])
+    assert_nil(@tree['/testdir', :acn])
+    assert_nil(@tree.node_info['/testdir'])
+    assert_nil(@tree['/'])
+    assert_nil(@tree.node_info['/'])
+    assert_equal(3, nrcalls)
+    assert_equal([@tree.dummy_root], @tree.node_access[:alcn].values)
+  end
+
+end

data/test/test_webgentask.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/webgentask'
+
+class TestWebgenTask < Test::Unit::TestCase
+
+  include Rake
+
+  def test_create
+    site = Webgen::WebgenTask.new('doit') do |s|
+      s.clobber_outdir = true
+      s.config_block = lambda {|c| c}
+      s.directory = 'website'
+    end
+    assert_equal('website', site.directory)
+    assert_equal(true, site.clobber_outdir)
+    assert_equal(5, site.config_block[5])
+    assert(Task['doit'])
+    assert(Task['clobber_doit'])
+  end
+
+end

data/test/test_website.rb

@@ -0,0 +1,98 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/website'
+require 'tmpdir'
+require 'fileutils'
+
+class TestWebsite < Test::Unit::TestCase
+
+  def test_initialize
+    ws = Webgen::Website.new('dir') do
+      assert_equal(ws, Webgen::WebsiteAccess.website)
+      throw :called
+    end
+    assert_nil(ws.blackboard)
+    assert_nil(ws.cache)
+    assert_nil(ws.config)
+    assert_nil(ws.tree)
+    assert_equal('dir', ws.directory)
+    assert_throws(:called) { ws.init }
+    assert_nil(Thread.current[:webgen_website])
+  end
+
+  def test_autoload_service
+    ws = Webgen::Website.new('unknown', nil)
+    ws.init
+    ws.instance_eval { @cache = Webgen::Cache.new }
+    ws.autoload_service('[]', 'Hash')
+    assert_equal([], ws.cache.permanent[:classes])
+    ws.blackboard.invoke('[]', 5)
+    assert_equal(['Hash'], ws.cache.permanent[:classes])
+  end
+
+  def test_init
+    ws = Webgen::Website.new('hallo')
+    ws.init
+    assert_not_nil(ws.config)
+    assert_not_nil(ws.blackboard)
+    assert_not_nil(ws.cache)
+    assert_not_nil(ws.tree)
+  end
+
+  def test_render_of_non_webgen_website
+    ws = Webgen::Website.new(File.dirname(__FILE__), nil) do |config|
+      config['website.cache'] = [:string, '']
+    end
+    assert_nil(ws.render)
+    assert(ws.config['website.cache'][1].length == 0)
+  end
+
+  def test_execute_in_env
+    ws = Webgen::Website.new('hallo')
+    assert_nil(Webgen::WebsiteAccess.website)
+    ws.execute_in_env { assert_not_nil(Webgen::WebsiteAccess.website) }
+  end
+
+  def test_read_config_file
+    dir = File.join(Dir.tmpdir, 'webgen-' + Process.pid.to_s)
+    FileUtils.mkdir_p(dir)
+
+    ws = Webgen::Website.new(dir)
+    ws.init
+    assert_equal('', ws.logger.log_output)
+    FileUtils.touch(File.join(dir, 'config.yml'))
+    ws.init
+    assert_match(/spelling error/, ws.logger.log_output)
+
+    File.open(File.join(dir, 'config.yaml'), 'w+') {|f| f.write('- unknown')}
+    assert_raise(Webgen::Website::ConfigFileInvalid) { ws.init }
+
+    File.open(File.join(dir, 'config.yaml'), 'w+') {|f| f.write('webgen.unknown: doit')}
+    assert_raise(Webgen::Website::ConfigFileInvalid) { ws.init }
+
+    File.open(File.join(dir, 'config.yaml'), 'w+') {|f| f.write("website.lang: de\ndefault_meta_info: {:all: {hallo: du}}")}
+    ws.init
+    assert_equal('de', ws.config['website.lang'])
+    assert_equal('du', ws.config['sourcehandler.default_meta_info'][:all]['hallo'])
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+  def test_clean
+    dir = File.join(Dir.tmpdir, 'webgen-' + Process.pid.to_s)
+    FileUtils.mkdir_p(dir)
+    FileUtils.mkdir_p(File.join(dir, 'src'))
+    FileUtils.touch(File.join(dir, 'src', 'test.jpg'))
+
+    ws = Webgen::Website.new(dir, nil)
+    assert_equal(:success, ws.render)
+    assert(File.exists?(File.join(dir, 'out', 'test.jpg')))
+    ws.clean
+    assert(!File.exists?(File.join(dir, 'out', 'test.jpg')))
+    assert(File.directory?(File.join(dir, 'out')))
+    ws.clean(true)
+    assert(!File.directory?(File.join(dir, 'out')))
+  end
+
+end

data/test/test_websiteaccess.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/websiteaccess'
+
+
+class TestWebsiteaccess < Test::Unit::TestCase
+
+  class WSAccessSubClass
+    include Webgen::WebsiteAccess
+
+    def get_private_website
+      website
+    end
+  end
+
+  def test_accessors
+    Thread.current[:webgen_website] = :value
+    assert_equal(:value, Webgen::WebsiteAccess.website)
+    assert_equal(:value, WSAccessSubClass.website)
+    assert_equal(:value, WSAccessSubClass.new.get_private_website)
+    Thread.current[:webgen_website] = nil
+  end
+
+end

data/test/test_websitemanager.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'fileutils'
+require 'tmpdir'
+require 'helper'
+require 'test/unit'
+require 'webgen/websitemanager'
+
+class TestWebsiteManager < Test::Unit::TestCase
+
+  def test_initialize
+    wm = Webgen::WebsiteManager.new('.')
+    t = wm.templates['default']
+    assert_equal('Thomas Leitner', t.author)
+    assert(t.paths.length > 0)
+
+    s = wm.styles['1024px']
+    assert(s.paths.length > 0)
+  end
+
+  def test_create_website
+    with_tmpdir do |dir|
+      wm = Webgen::WebsiteManager.new(dir)
+      wm.create_website
+      assert(File.directory?(File.join(dir, 'ext')))
+      assert(File.directory?(File.join(dir, 'src')))
+      assert(File.file?(File.join(dir, 'README')))
+      assert(File.file?(File.join(dir, 'config.yaml')))
+    end
+  end
+
+  def test_apply_template
+    with_tmpdir do |dir|
+      wm = Webgen::WebsiteManager.new(dir)
+      assert_raise(RuntimeError) { wm.apply_template('default') }
+
+      Dir.mkdir(dir)
+      wm.apply_template('default')
+      assert(File.directory?(File.join(dir, 'src')))
+      assert(File.file?(File.join(dir, 'src', 'index.page')))
+
+      assert_raise(ArgumentError) { wm.apply_template('unknown-template') }
+    end
+  end
+
+  def test_apply_style
+    dir = with_tmpdir
+    wm = Webgen::WebsiteManager.new(dir)
+    assert_raise(RuntimeError) { wm.apply_style('simple') }
+
+    wm.styles.each do |name, infos|
+      Dir.mkdir(dir)
+      wm.apply_style(name)
+      assert(File.directory?(File.join(dir, 'src')))
+      assert(File.file?(File.join(dir, 'src', 'default.template')))
+      assert(File.file?(File.join(dir, 'src', 'default.css')))
+      FileUtils.rm_rf(dir)
+    end
+    assert_raise(ArgumentError) { wm.apply_style('unknown-style') }
+  end
+
+  def with_tmpdir
+    dir = File.join(Dir.tmpdir, 'webgen-' + Process.pid.to_s)
+    yield(dir) if block_given?
+    dir
+  ensure
+    FileUtils.rm_rf(dir)
+  end
+
+end