webgen 0.5.17 → 1.0.0.beta1

data/test/webgen/item_tracker/test_file.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'time'
+require 'webgen/item_tracker/file'
+
+class TestItemTrackerFile < MiniTest::Unit::TestCase
+
+  def setup
+    @website = MiniTest::Mock.new
+    @obj = Webgen::ItemTracker::File.new(@website)
+  end
+
+  def test_item_id
+    assert_equal('filename', @obj.item_id('filename'))
+  end
+
+  def test_item_data
+    assert_equal(File.mtime(__FILE__), @obj.item_data(__FILE__))
+  end
+
+  def test_changed?
+    refute(@obj.changed?(__FILE__, Time.now))
+    assert(@obj.changed?(__FILE__, Time.parse("1980-01-01")))
+  end
+
+  def test_node_referenced?
+    refute(@obj.node_referenced?('anything', 'nothing', '/alcn'))
+  end
+
+end

data/test/webgen/item_tracker/test_missing_node.rb

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/item_tracker/missing_node'
+require 'webgen/blackboard'
+
+class TestItemTrackerMissingNode < MiniTest::Unit::TestCase
+
+  class StubTree
+
+    attr_accessor :answer
+
+    def resolve_node(path, lang)
+      @answer
+    end
+
+  end
+
+  def setup
+    @website = MiniTest::Mock.new
+    @website.expect(:tree, StubTree.new)
+    @website.expect(:blackboard, Webgen::Blackboard.new)
+    @obj = Webgen::ItemTracker::MissingNode.new(@website)
+  end
+
+  def test_item_id
+    assert_equal(['id', nil], @obj.item_id('id'))
+    assert_equal(['id', 'lang'], @obj.item_id('id', 'lang'))
+  end
+
+  def test_item_data
+    @website.tree.answer = nil
+    assert_equal(true, @obj.item_data('id', 'lang'))
+    @website.tree.answer = :a42
+    assert_same(false, @obj.item_data('id', 'lang'))
+  end
+
+  def test_changed?
+    @website.tree.answer = nil
+
+    # run where missing node item was added
+    assert(@obj.changed?(['alcn', 'lang'], true))
+
+    @website.blackboard.dispatch_msg(:after_all_nodes_written)
+
+    # run where at least one new node was created
+    @website.blackboard.dispatch_msg(:after_node_created)
+    assert(@obj.changed?(['alcn', 'lang'], true))
+
+    @website.blackboard.dispatch_msg(:after_all_nodes_written)
+    @website.blackboard.dispatch_msg(:after_all_nodes_written)
+
+    # run where no new nodes were created and therefore "changing" stops
+    refute(@obj.changed?(['alcn', 'lang'], true))
+
+    @website.blackboard.dispatch_msg(:after_all_nodes_written)
+    @website.blackboard.dispatch_msg(:website_generated)
+
+    # on next invocation of website generation
+    @website.tree.answer = :a42
+    assert(@obj.changed?(['alcn', 'lang'], true))
+    refute(@obj.changed?(['alcn', 'lang'], false))
+  end
+
+  def test_node_referenced?
+    assert(@obj.node_referenced?(['alcn', 'lang'], true, 'alcn'))
+    refute(@obj.node_referenced?(['other', 'lang'], true, 'alcn'))
+  end
+
+end

data/test/webgen/item_tracker/test_node_content.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/item_tracker/node_content'
+
+class TestNodeContent < MiniTest::Unit::TestCase
+
+  def setup
+    @website = MiniTest::Mock.new
+    @obj = Webgen::ItemTracker::NodeContent.new(@website)
+  end
+
+  def test_item_id
+    assert_equal('id', @obj.item_id('id'))
+  end
+
+  def test_item_data
+    assert_nil(@obj.item_data('alcn'))
+  end
+
+  def test_changed?
+    item_tracker = MiniTest::Mock.new
+    item_tracker.expect(:node_changed?, true, [:node])
+    ext = MiniTest::Mock.new
+    ext.expect(:item_tracker, item_tracker)
+    @website.expect(:ext, ext)
+    @website.expect(:tree, {'alcn' => :node})
+
+    assert(@obj.changed?('unknown', 'old'))
+    assert(@obj.changed?('alcn', 'other'))
+
+    @website.verify
+    item_tracker.verify
+    ext.verify
+  end
+
+  def test_node_referenced?
+    assert(@obj.node_referenced?('alcn', nil, 'alcn'))
+    refute(@obj.node_referenced?('other', nil, 'alcn'))
+  end
+
+end

data/test/webgen/item_tracker/test_node_meta_info.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/item_tracker/node_meta_info'
+
+class TestNodeMetaInfo < MiniTest::Unit::TestCase
+
+  def setup
+    @website = MiniTest::Mock.new
+    @node = MiniTest::Mock.new
+    @node.expect(:meta_info, {'key' => 'value'})
+    @website.expect(:tree, {'alcn' => @node})
+    @obj = Webgen::ItemTracker::NodeMetaInfo.new(@website)
+  end
+
+  def test_item_id
+    assert_equal(['id', nil], @obj.item_id('id'))
+    assert_equal(['id', 'key'], @obj.item_id('id', 'key'))
+  end
+
+  def test_item_data
+    assert_equal({'key' => 'value'}, @obj.item_data('alcn'))
+    refute_same(@node.meta_info, @obj.item_data('alcn'))
+    assert_equal('value', @obj.item_data('alcn', 'key'))
+    refute_same(@node.meta_info['key'], @obj.item_data('alcn', 'key'))
+    @website.verify
+    @node.verify
+  end
+
+  def test_changed?
+    @node.expect(:nil?, false)
+    assert(@obj.changed?(['unknown', nil], 'old'))
+    assert(@obj.changed?(['alcn', nil], {"key" => 'value', 'other' => 'new'}))
+    assert(@obj.changed?(['alcn', 'key'], 'new'))
+    @website.verify
+    @node.verify
+  end
+
+  def test_node_referenced?
+    assert(@obj.node_referenced?(['alcn', nil], 'mi', 'alcn'))
+    refute(@obj.node_referenced?(['other', nil], 'mi', 'alcn'))
+  end
+
+end

data/test/webgen/item_tracker/test_nodes.rb

@@ -0,0 +1,61 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/item_tracker/nodes'
+require 'webgen/node_finder'
+
+class TestItemTrackerNodes < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def self.node_list(website, options)
+    website.tree.root.children
+  end
+
+  def setup
+    setup_website('node_finder.option_sets' => {})
+    @website.ext.node_finder =  Webgen::NodeFinder.new(@website)
+    @obj = Webgen::ItemTracker::Nodes.new(@website)
+    @args1 = [['TestItemTrackerNodes', 'node_list'], {}, :meta_info]
+    @args2 = [:node_finder_option_set, {:opts => {:alcn => '/file*'}, :ref_alcn => '/'}, :meta_info]
+  end
+
+  def test_item_id
+    assert_equal(@args1, @obj.item_id(*@args1))
+    assert_equal(@args2, @obj.item_id(*@args2))
+  end
+
+  def test_item_data
+    setup_default_nodes(@website.tree)
+
+    assert_equal(["/file.en.html", "/file.de.html", "/other.html", "/other.en.html", "/german.de.html", "/dir/", "/dir2/"],
+                 @obj.item_data(*@args1))
+
+    assert_equal([["/file.en.html", [["/file.en.html#frag", ["/file.en.html#nested"]]]],
+                  ["/file.de.html", ["/file.de.html#frag"]]],
+                 @obj.item_data(*@args2))
+  end
+
+  def test_changed?
+    setup_default_nodes(@website.tree)
+    @website.ext.item_tracker = MiniTest::Mock.new
+    @website.ext.item_tracker.expect(:item_changed?, false, [:node_meta_info, nil])
+
+    [@args1, @args2].each do |args|
+      old_data = @obj.item_data(*args)
+      assert(@obj.changed?(args, []))
+      refute(@obj.changed?(args, old_data))
+    end
+  end
+
+  def test_node_referenced?
+    setup_default_nodes(@website.tree)
+
+    assert(@obj.node_referenced?(@args1, @obj.item_data(*@args1), '/file.en.html'))
+    refute(@obj.node_referenced?(@args1, @obj.item_data(*@args1), '/dir/file.html'))
+
+    assert(@obj.node_referenced?(@args2, @obj.item_data(*@args2), '/file.en.html'))
+    refute(@obj.node_referenced?(@args2, @obj.item_data(*@args2), '/other.en.html'))
+  end
+
+end

data/test/webgen/path_handler/test_base.rb

@@ -0,0 +1,153 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/base'
+require 'time'
+
+class TestPathHandlerBase < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  class TestPathHandler
+    include Webgen::PathHandler::Base
+
+    public :parent_node
+    public :dest_path
+    public :node_exists?
+    public :create_node
+  end
+
+  def setup
+    setup_website
+    @obj = TestPathHandler.new(@website)
+  end
+
+  def test_content
+    assert_nil(@obj.content(nil))
+  end
+
+  def test_create_node
+    count = 0
+    assert_nil(@obj.create_node(Webgen::Path.new('/test.html', 'draft' => true)))
+
+    path = Webgen::Path.new('/path.html', 'dest_path' => '<parent><basename>(.<lang>)<ext>',
+                            'modified_at' => 'unknown', 'parent_alcn' => '')
+    node = @obj.create_node(path) {|n| count += 1; assert_kind_of(Webgen::Node, n)}
+    assert_equal(path, node.node_info[:path])
+    assert_kind_of(Time, node.meta_info['modified_at'])
+    assert_equal(1, count)
+
+    second_node = @obj.create_node(path) {|n| count += 1}
+    assert_equal(1, count)
+    assert_equal(second_node, node)
+  end
+
+  def test_parent_node
+    assert_equal(@website.tree.dummy_root, @obj.parent_node(Webgen::Path.new('/')))
+    root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    dir = Webgen::Node.new(root, 'dir/', '/dir/')
+    assert_equal(root, @obj.parent_node(Webgen::Path.new('/test/')))
+    assert_raises(Webgen::NodeCreationError) { @obj.parent_node(Webgen::Path.new('/hallo/other.page')) }
+    assert_equal(dir, @obj.parent_node(Webgen::Path.new('/dir/test/')))
+    assert_equal(root, @obj.parent_node(Webgen::Path.new('/dir/test/', 'parent_alcn' => '/')))
+  end
+
+  def test_dest_path
+    config = @website.config
+    config['website.lang'] = 'en'
+    node = Webgen::Node.new(@website.tree.dummy_root, '/', '/', {:test => :value})
+
+    assert_raises(Webgen::NodeCreationError) { @obj.dest_path(node, Webgen::Path.new('/test')) }
+
+    check_dest_path = lambda do |path, mi, expected, parent = node|
+      assert_equal(expected, @obj.dest_path(parent, Webgen::Path.new(path, mi)))
+    end
+
+    mi = {'dest_path' => '<parent><basename>(-<version>)(.<lang>)<ext>'}
+
+    config['path_handler.lang_code_in_dest_path'] = true
+    check_dest_path.call('/path.html', mi, '/path.html')
+    check_dest_path.call('/path.en.html', mi, '/path.en.html')
+    check_dest_path.call('/path.eo.html', mi, '/path.eo.html')
+
+    config['path_handler.lang_code_in_dest_path'] = false
+    check_dest_path.call('/path.html', mi, '/path.html')
+    check_dest_path.call('/path.en.html', mi, '/path.html')
+    check_dest_path.call('/path.eo.html', mi, '/path.html')
+
+    config['path_handler.lang_code_in_dest_path'] = 'except_default'
+    check_dest_path.call('/path.html', mi, '/path.html')
+    check_dest_path.call('/path.en.html', mi, '/path.html')
+    check_dest_path.call('/path.eo.html', mi, '/path.eo.html')
+    check_dest_path.call('/dir/', mi, '/dir/')
+
+    config['path_handler.version_in_dest_path'] = true
+    check_dest_path.call('/path.html', mi.merge('version' => 'default'), '/path-default.html')
+    check_dest_path.call('/path.html', mi.merge('version' => 'other'), '/path-other.html')
+
+    config['path_handler.version_in_dest_path'] = false
+    check_dest_path.call('/path.html', mi.merge('version' => 'default'), '/path.html')
+    check_dest_path.call('/path.html', mi.merge('version' => 'other'), '/path.html')
+
+    config['path_handler.version_in_dest_path'] = 'except_default'
+    check_dest_path.call('/path.html', mi.merge('version' => 'default'), '/path.html')
+    check_dest_path.call('/path.html', mi.merge('version' => 'other'), '/path-other.html')
+
+    other = Webgen::Node.new(node, 'other.page', '/path.html')
+    check_dest_path.call('/path.html', mi, '/path.html')
+    check_dest_path.call('/path.en.html', mi, '/path.en.html')
+
+    check_dest_path.call('/path.html#frag', mi, '/path.html#frag', other)
+    frag = Webgen::Node.new(other, '#frag', '/path.html#frag')
+    check_dest_path.call('/path.html#frag1', mi, '/path.html#frag1', frag)
+
+    check_dest_path.call('/', mi, '/', @website.tree.dummy_root)
+
+    index_en = Webgen::Node.new(node, 'index.page', '/index.html', {'lang' => 'en'})
+    check_dest_path.call('/index.en.html', mi, '/index.html')
+    check_dest_path.call('/index.en.html', {'dest_path' => "<parent>hallo.html"}, '/hallo.html')
+    check_dest_path.call('/other.de.html', {'dest_path' => "<parent>index(.<lang>)<ext>"}, '/index.de.html')
+
+    assert_raises(Webgen::NodeCreationError) do
+      check_dest_path.call('/path.html', {'dest_path' => "<parent><year>/<month>/<basename><ext>"}, 'unused')
+    end
+    time = Time.parse('2008-09-04 08:15')
+    check_dest_path.call('/path.html',
+                         {'dest_path' => "<parent><year>/<month>/<day>-<basename><ext>", 'created_at' => time},
+                         '/2008/09/04-path.html')
+
+
+    dir = Webgen::Node.new(node, 'nested.path', '/dir1/dir2/dir3/')
+    check_dest_path.call('/path.html', {'dest_path' => "<parent1><parent2><parent3><parent4>"},
+                         'dir1dir2dir3', dir)
+    check_dest_path.call('/path.html', {'dest_path' => "<parent-4><parent-3><parent-2><parent-1>"},
+                         'dir1dir2dir3', dir)
+    check_dest_path.call('/path.html', {'dest_path' => "<parent2..-1>"},
+                         'dir2/dir3', dir)
+    assert_raises(Webgen::NodeCreationError) do
+      check_dest_path.call('/path.html', {'dest_path' => "<parent0>"}, 'unused')
+    end
+
+    check_dest_path.call('/path.html', {'dest_path' => "webgen:this is not changed"},
+                         'this is not changed')
+
+    assert_raises(Webgen::NodeCreationError) do
+      check_dest_path.call('/path.html', {'dest_path' => "<hallo>"}, 'unused')
+    end
+
+  end
+
+  def test_node_exists
+    node = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    child_de = Webgen::Node.new(node, 'somename.html', '/somename.html', {'lang' => 'de'})
+    frag_de = Webgen::Node.new(child_de, '#othertest', '/somename.html#data1')
+
+    assert_equal(child_de, @obj.node_exists?(Webgen::Path.new('/somename.de.html'), '/unknown.html'))
+    assert_equal(child_de, @obj.node_exists?(Webgen::Path.new('/other.page'), '/somename.html'))
+    assert_equal(false, @obj.node_exists?(Webgen::Path.new('/somename.en.html', {'no_output' => true}),
+                                          '/somename.html'))
+    assert_equal(frag_de, @obj.node_exists?(Webgen::Path.new('/somename.de.html#othertest'), '/somename.html#no'))
+    assert_equal(nil, @obj.node_exists?(Webgen::Path.new('/unknown'), '/unknown'))
+  end
+
+end

data/test/webgen/path_handler/test_copy.rb

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/copy'
+require 'webgen/content_processor'
+require 'webgen/path'
+
+class TestPathHandlerCopy < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website
+    @website.ext.content_processor = Webgen::ContentProcessor.new
+    @website.ext.content_processor.register('test') do |context|
+      context.content = context.content.reverse
+    end
+    @website.ext.content_processor.register('ha', :ext_map => {'ha' => 'llo'}) do |context|
+      context.content = context.content.reverse
+    end
+
+    @copy = Webgen::PathHandler::Copy.new(@website)
+    @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+  end
+
+  def test_create_node
+    check_node = lambda do |src_path, mi, dest_path, pipeline|
+      node = @copy.create_nodes(Webgen::Path.new(src_path, {'dest_path' => '<parent><basename><ext>'}.merge(mi)))
+      refute_nil(node)
+      assert_equal(pipeline, node.meta_info['pipeline'])
+      assert_equal(dest_path, node.dest_path)
+    end
+
+    check_node.call('/default.css', {}, '/default.css', nil)
+    check_node.call('/other.test.css', {}, '/other.css', ['test'])
+    check_node.call('/other.unknown.css', {}, '/other.unknown.css', nil)
+    check_node.call('/first.test.test.unknown.css', {}, '/first.unknown.css', ['test', 'test'])
+    check_node.call('/first.test.test.unknown.ha', {}, '/first.unknown.llo', ['test', 'test', :ha])
+    check_node.call('/first.ha', {}, '/first.llo', [:ha])
+    check_node.call('/other.test.css', {'pipeline' => ['testing']}, '/other.test.css', ['testing'])
+    check_node.call('/other.unke.css', {'pipeline' => ['test']}, '/other.unke.css', ['test'])
+    check_node.call('/other', {}, '/other', nil)
+  end
+
+  def test_content
+    path = Webgen::Path.new('/default.css', 'dest_path' => '<parent><basename><ext>') {StringIO.new('# header')}
+    node = @copy.create_nodes(path)
+    assert_kind_of(Webgen::Path, @copy.content(node))
+    assert_equal('# header', @copy.content(node).data)
+
+    path = Webgen::Path.new('/other.test.css', 'dest_path' => '<parent><basename><ext>') {StringIO.new('# other')}
+    node = @copy.create_nodes(path)
+    assert_equal('# other'.reverse, @copy.content(node))
+  end
+
+end