webgen 1.0.0.beta2 → 1.0.0.beta3

data/test/webgen/content_processor/test_tikz.rb

@@ -15,7 +15,7 @@ class TestContentProcessorTikz < MiniTest::Unit::TestCase
     template_data = File.read(File.join(Webgen::Utils.data_dir, 'passive_sources', 'templates', 'tikz.template'))
     node = RenderNode.new(template_data, @website.tree.dummy_root, '/template', '/template')
 
-    @context.node.expect(:[], nil, ['ignored'])
+    @context.node.define_singleton_method(:[]) {|ignored| nil}
 
     call('\tikz \draw (0,0) -- (0,1);', 'test.png', [], '', '72 72', false)
     refute_nil(@context.content)
@@ -28,7 +28,7 @@ class TestContentProcessorTikz < MiniTest::Unit::TestCase
 
   def call(content, path, libs, opts, res, trans)
     @context.content = content
-    @context.dest_node.expect(:dest_path, path)
+    @context.dest_node.define_singleton_method(:dest_path) {path}
     @context.website.config.update('content_processor.tikz.resolution' => res,
                                    'content_processor.tikz.transparent' => trans,
                                    'content_processor.tikz.libraries' => libs,
@@ -37,4 +37,8 @@ class TestContentProcessorTikz < MiniTest::Unit::TestCase
     Webgen::ContentProcessor::Tikz.call(@context)
   end
 
+  def teardown
+    FileUtils.rm_rf(@website.directory)
+  end
+
 end

data/test/webgen/destination/test_file_system.rb

@@ -7,9 +7,9 @@ require 'webgen/path'
 class TestDestinationFileSystem < MiniTest::Unit::TestCase
 
   def setup
-    @website = MiniTest::Mock.new
-    @dir = Dir.mktmpdir('test-webgen')
-    @website.expect(:directory, @dir)
+    @dir = dir = Dir.mktmpdir('test-webgen')
+    @website = Object.new
+    @website.define_singleton_method(:directory) { dir }
   end
 
   def teardown
@@ -23,7 +23,6 @@ class TestDestinationFileSystem < MiniTest::Unit::TestCase
     assert_equal('/tmp/hallo', dest.root)
     dest = Webgen::Destination::FileSystem.new(@website, '../hallo')
     assert_equal(File.expand_path(File.join(@dir, '../hallo')), dest.root)
-    @website.verify
   end
 
   def test_file_methods

data/test/webgen/item_tracker/test_missing_node.rb

@@ -17,9 +17,9 @@ class TestItemTrackerMissingNode < MiniTest::Unit::TestCase
   end
 
   def setup
-    @website = MiniTest::Mock.new
-    @website.expect(:tree, StubTree.new)
-    @website.expect(:blackboard, Webgen::Blackboard.new)
+    @website = OpenStruct.new
+    @website.tree = StubTree.new
+    @website.blackboard = Webgen::Blackboard.new
     @obj = Webgen::ItemTracker::MissingNode.new(@website)
   end
 

data/test/webgen/item_tracker/test_node_content.rb

@@ -6,12 +6,14 @@ require 'webgen/item_tracker/node_content'
 class TestNodeContent < MiniTest::Unit::TestCase
 
   def setup
-    @website = MiniTest::Mock.new
+    @website = Object.new
     @obj = Webgen::ItemTracker::NodeContent.new(@website)
   end
 
   def test_item_id
-    assert_equal('id', @obj.item_id('id'))
+    s = 'id'
+    def s.alcn; self; end
+    assert_equal('id', @obj.item_id(s))
   end
 
   def test_item_data
@@ -19,19 +21,14 @@ class TestNodeContent < MiniTest::Unit::TestCase
   end
 
   def test_item_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})
+    ext = OpenStruct.new
+    ext.item_tracker = Object.new
+    ext.item_tracker.define_singleton_method(:node_changed?) {|n| raise unless n == :node; true}
+    @website.define_singleton_method(:ext) { ext }
+    @website.define_singleton_method(:tree) { {'alcn' => :node} }
 
     assert(@obj.item_changed?('unknown', 'old'))
     assert(@obj.item_changed?('alcn', 'other'))
-
-    @website.verify
-    item_tracker.verify
-    ext.verify
   end
 
   def test_referenced_nodes

data/test/webgen/item_tracker/test_node_meta_info.rb

@@ -6,16 +6,17 @@ 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})
+    @website = Object.new
+    @node = node = Object.new
+    @node.define_singleton_method(:meta_info) { {'key' => 'value'} }
+    @website.define_singleton_method(: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'))
+    @node.define_singleton_method(:alcn) { 'id' }
+    assert_equal(['id', nil], @obj.item_id(@node))
+    assert_equal(['id', 'key'], @obj.item_id(@node, 'key'))
   end
 
   def test_item_data
@@ -23,17 +24,12 @@ class TestNodeMetaInfo < MiniTest::Unit::TestCase
     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_item_changed?
-    @node.expect(:nil?, false)
     assert(@obj.item_changed?(['unknown', nil], 'old'))
     assert(@obj.item_changed?(['alcn', nil], {"key" => 'value', 'other' => 'new'}))
     assert(@obj.item_changed?(['alcn', 'key'], 'new'))
-    @website.verify
-    @node.verify
   end
 
   def test_referenced_nodes

data/test/webgen/item_tracker/test_nodes.rb

@@ -9,7 +9,7 @@ class TestItemTrackerNodes < MiniTest::Unit::TestCase
   include Webgen::TestHelper
 
   def self.node_list(website, options)
-    website.tree.root.children
+    website.tree.root.children.select {|c| c.alcn =~ /^\/file/}
   end
 
   def setup
@@ -17,7 +17,7 @@ class TestItemTrackerNodes < MiniTest::Unit::TestCase
     @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]
+    @args2 = [:node_finder_option_set, {:opts => {:alcn => ['/file.de*', '/file.*.html']}, :ref_alcn => '/'}, :meta_info]
   end
 
   def test_item_id
@@ -28,10 +28,10 @@ class TestItemTrackerNodes < MiniTest::Unit::TestCase
   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/"],
+    assert_equal(["/file.en.html", "/file.de.html"],
                  @obj.item_data(*@args1))
 
-    assert_equal([["/file.en.html", [["/file.en.html#frag", ["/file.en.html#nested"]]]],
+    assert_equal(["/file.en.html",
                   ["/file.de.html", ["/file.de.html#frag"]]],
                  @obj.item_data(*@args2))
   end
@@ -39,13 +39,19 @@ class TestItemTrackerNodes < MiniTest::Unit::TestCase
   def test_item_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])
+    2.times do
+      @website.ext.item_tracker.expect(:item_changed?, false, [:node_meta_info, @website.tree['/file.en.html']])
+      @website.ext.item_tracker.expect(:item_changed?, false, [:node_meta_info, @website.tree['/file.de.html']])
+    end
+    @website.ext.item_tracker.expect(:item_changed?, false, [:node_meta_info, @website.tree['/file.de.html#frag']])
 
     [@args1, @args2].each do |args|
       old_data = @obj.item_data(*args)
       assert(@obj.item_changed?(args, []))
       refute(@obj.item_changed?(args, old_data))
     end
+
+    @website.ext.item_tracker.verify
   end
 
   def test_referenced_nodes

data/test/webgen/path_handler/test_api.rb

@@ -0,0 +1,111 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/api'
+
+class TestPathHandlerApi < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website('website.lang' => 'en')
+
+    @api = Webgen::PathHandler::Api.new(@website)
+
+    root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+
+    @path = Webgen::Path.new('/test.api', 'dest_path' => '<parent><basename><ext>',
+                             'api_name' => 'my_api',
+                             'dir_name' => 'my_dir',
+                             'prefix_for_link_defs' => true,
+                             'rdoc_options' => ['-t', 'Title', __FILE__])
+  end
+
+  def teardown
+    FileUtils.rm_rf(@website.directory)
+  end
+
+  def test_create_nodes
+    @website.ext.path_handler = Webgen::PathHandler.new(@website)
+    @website.ext.path_handler.register('Directory')
+    @website.ext.path_handler.register('Page')
+    @website.ext.path_handler.register('Copy')
+    @website.ext.link_definitions = {}
+    @api.create_nodes(@path, nil)
+
+    assert(@website.tree['/my_dir/TestPathHandlerApi.en.html'])
+    assert_equal(['/my_dir/TestPathHandlerApi.en.html', 'TestPathHandlerApi'],
+                 @website.ext.link_definitions['my_api:TestPathHandlerApi'])
+    assert(@website.tree['/my_dir/TestPathHandlerApi.en.html#method-i-setup'])
+    assert_equal(['/my_dir/TestPathHandlerApi.en.html#method-i-setup', 'TestPathHandlerApi#setup'],
+                 @website.ext.link_definitions['my_api:TestPathHandlerApi#setup'])
+
+    cache_dir = @website.tmpdir(File.join('path_handler.api', 'my_api'))
+    assert(File.directory?(cache_dir))
+  end
+
+  def test_rdoc_options
+    data_methods = [:verbosity, :dry_run, :update_output_dir,
+                    :force_output, :files]
+    result = [0, false, true, false, [__FILE__]]
+
+    options = @api.send(:rdoc_options, @path['rdoc_options'])
+    assert_equal(result, data_methods.map {|m| options.send(m)})
+
+    options = @api.send(:rdoc_options, @path['rdoc_options'].join(' '))
+    assert_equal(result, data_methods.map {|m| options.send(m)})
+  end
+
+  def test_rdoc_store
+    options = @api.send(:rdoc_options, @path['rdoc_options'])
+    store = @api.send(:rdoc_store, options, 'dir')
+
+    data = [store.dry_run, store.main, store.title, store.path]
+    result = [false, nil, 'Title', 'dir']
+
+    assert_equal(result, data)
+  end
+
+=begin
+  def create_nodes
+    @path['version'] = 'atom'
+    atom_node = @feed.create_nodes(@path.dup, @path_blocks)
+    @path['version'] = 'rss'
+    rss_node = @feed.create_nodes(@path.dup, @path_blocks)
+    [atom_node, rss_node]
+  end
+
+  def test_create_node
+    atom_node, rss_node = create_nodes
+
+    refute_nil(atom_node)
+    refute_nil(rss_node)
+    refute_nil(atom_node.node_info[:blocks])
+    assert_equal('atom', atom_node['version'])
+    assert_equal('rss', rss_node['version'])
+
+    assert_raises(Webgen::NodeCreationError) do
+      path = Webgen::Path.new('/test_feed_2') { StringIO.new("---\nunknow: yes") }
+      @feed.create_nodes(path, 'unused')
+    end
+  end
+
+  def test_content
+    @website.ext.content_processor = Webgen::ContentProcessor.new
+    @website.ext.content_processor.register('Erb')
+    @website.ext.content_processor.register('Blocks')
+
+    atom_node, rss_node = create_nodes
+    assert_equal("hallo\n", @feed.content(rss_node))
+    assert(@feed.content(atom_node) =~ /Thomas Leitner/)
+    assert(@feed.content(atom_node) =~ /RealContent/)
+  end
+
+  def test_feed_entries
+    atom_node, rss_node = create_nodes
+    assert_equal([@index_en, @file_en], atom_node.feed_entries)
+    assert_equal([@index_en, @file_en], rss_node.feed_entries)
+  end
+=end
+
+end

data/test/webgen/path_handler/test_page_utils.rb

@@ -27,7 +27,7 @@ class TestPageUtils < MiniTest::Unit::TestCase
 
   def test_template_chain
     setup_website('path_handler.default_template' => 'default.template')
-    @website.expect(:cache, Webgen::Cache.new)
+    @website.cache = Webgen::Cache.new
     @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
 
     default_template = MyHandler::Node.new(@root, 'default.template', '/default.template')

data/test/webgen/source/test_file_system.rb

@@ -9,9 +9,9 @@ require 'webgen/source/file_system'
 class TestSourceFileSystem < MiniTest::Unit::TestCase
 
   def setup
-    @website = MiniTest::Mock.new
-    @root = File.expand_path(File.dirname(__FILE__))
-    @website.expect(:directory, @root)
+    @root = root = File.expand_path(File.dirname(__FILE__))
+    @website = Object.new
+    @website.define_singleton_method(:directory) { root }
   end
 
   def test_initialize

data/test/webgen/tag/test_coderay.rb

@@ -9,14 +9,13 @@ class TestTagCoderay < MiniTest::Unit::TestCase
 
   def test_call
     setup_context
-    @website.ext.content_processor = MiniTest::Mock.new
-    @website.ext.content_processor.expect(:call, @context, ['tags', @context])
+    @website.ext.content_processor = Object.new
+    @website.ext.content_processor.define_singleton_method(:call) {|_, context| context}
     root = Webgen::Node.new(@website.tree.dummy_root, '/', '/', {'title' => 'Hallo'})
     @context[:chain] = [root]
 
     assert_result_includes('TestData', @context, 'TestData', 'html', false, 'style')
-    @context.content = 'Hallo'
-    assert_result_includes('Hallo', @context, '{title:}', :ruby, true, 'other')
+    assert_result_includes('title', @context, '{title:}', :ruby, true, 'other')
     assert_result_includes('class="constant"', @context, 'TestData', 'ruby', false, 'other')
   end
 

data/test/webgen/tag/test_meta_info.rb

@@ -20,6 +20,9 @@ class TestTagMetaInfo < MiniTest::Unit::TestCase
 
     @context[:config] = {'tag.meta_info.escape_html' => false}
     assert_equal("value <br />", Webgen::Tag::MetaInfo.call('key', '', @context))
+
+    @context[:config] = {'tag.meta_info.mi' => 'key'}
+    assert_equal("value <br />", Webgen::Tag::MetaInfo.call('meta_info', '', @context))
   end
 
 end

data/test/webgen/task/test_create_website.rb

@@ -38,8 +38,8 @@ class TestTaskCreateWebsite < MiniTest::Unit::TestCase
       assert(File.directory?(@website.directory))
       assert(File.directory?(File.join(@website.directory, 'tmp')))
       assert_equal(tmpdir, File.read(File.join(@website.directory, 'tmp', 'test.txt')))
-      refute(File.directory?(File.join(@website.directory, 'src')))
-      refute(File.file?(File.join(@website.directory, 'webgen.config')))
+      assert(File.directory?(File.join(@website.directory, 'src')))
+      assert(File.file?(File.join(@website.directory, 'webgen.config')))
     end
   end
 

data/test/webgen/test_item_tracker.rb

@@ -4,6 +4,7 @@ require 'minitest/autorun'
 require 'webgen/item_tracker'
 require 'webgen/blackboard'
 require 'webgen/cache'
+require 'webgen/node'
 
 class Webgen::ItemTracker::Sample
 
@@ -31,22 +32,19 @@ end
 
 class TestItemTracker < MiniTest::Unit::TestCase
 
+  DummyNode = Struct.new(:alcn)
+
   Data = {'/alcn' => 'mydata'}
 
   def test_functionality
-    # Needed mock objects
-    website = MiniTest::Mock.new
-    website.expect(:blackboard, blackboard = Webgen::Blackboard.new)
-    website.expect(:cache, cache = Webgen::Cache.new)
-    node = MiniTest::Mock.new
-    node.expect(:alcn, '/alcn')
-    node.expect(:!, false)
-    node.expect(:hash, 12345)
-    other = MiniTest::Mock.new
-    other.expect(:alcn, '/other')
-    other.expect(:!, false)
-    other.expect(:hash, 12346)
-    website.expect(:tree, {'/alcn' => node, '/other' => other})
+    # Needed stub objects
+    website = Struct.new(:blackboard, :cache, :tree).new
+    website.blackboard = blackboard = Webgen::Blackboard.new
+    website.cache = cache = Webgen::Cache.new
+
+    node = DummyNode.new('/alcn')
+    other = DummyNode.new('/other')
+    website.tree = {'/alcn' => node, '/other' => other}
 
     tracker = Webgen::ItemTracker.new(website)
     tracker.register('Sample')
@@ -101,9 +99,6 @@ class TestItemTracker < MiniTest::Unit::TestCase
     blackboard.dispatch_msg(:after_all_nodes_written)
 
     assert(tracker.node_referenced?(node))
-
-    website.verify
-    node.verify
   end
 
 end

data/test/webgen/test_node.rb

@@ -99,6 +99,8 @@ class TestNode < MiniTest::Unit::TestCase
 
     n = Webgen::Node.new(tree['/'], 'testing', '../../.././dir2')
     assert_equal('../dir2', tree['/dir/subfile.html'].route_to(n))
+
+    assert_equal('../routed.html', tree['/dir2/index.en.html'].route_to(tree['/file.en.html#nested']))
   end
 
   def test_proxy_node

data/test/webgen/test_node_finder.rb

@@ -55,12 +55,17 @@ class TestNodeFinder < MiniTest::Unit::TestCase
                  ],
                  @nf.find({:levels => [2,3]}, tree['/']))
 
-    # test sort methods
+    # test sort and reverse
     check.call(%w[/file.en.html /file.de.html /dir/dir/file.html /german.de.html /dir2/index.de.html
                   /dir2/index.en.html /other.html /other.en.html /dir/subfile.html],
                @nf.find({:alcn => '/**/*.html', :flatten => true, :sort => true}, tree['/']))
+    check.call(%w[/dir/subfile.html /other.en.html /other.html /dir2/index.en.html /dir2/index.de.html
+                   /german.de.html /dir/dir/file.html /file.de.html /file.en.html],
+               @nf.find({:alcn => '/**/*.html', :flatten => true, :sort => true, :reverse => true}, tree['/']))
     check.call(%w[/german.de.html /other.en.html /other.html /file.en.html /file.de.html],
                @nf.find({:alcn => '/*.html', :flatten => true, :sort => 'sort_info'}, tree['/']))
+    check.call(%w[/file.de.html /file.en.html /other.html /other.en.html /german.de.html],
+               @nf.find({:alcn => '/*.html', :flatten => true, :sort => 'sort_info', :reverse => true}, tree['/']))
     check.call(%w[/dir/dir/file.html /file.de.html /file.en.html /german.de.html /dir2/index.de.html /dir2/index.en.html
                   /other.html /other.en.html /dir/subfile.html],
                @nf.find({:alcn => '/**/*.html', :name => 'test', :flatten => true, :sort => 'title'}, tree['/']))
@@ -72,6 +77,14 @@ class TestNodeFinder < MiniTest::Unit::TestCase
                   tree['/german.de.html'], tree['/other.html'], tree['/other.en.html'],
                  ],
                  @nf.find({:levels => [2,4], :sort => true}, tree['/']))
+    assert_equal([tree['/other.en.html'], tree['/other.html'], tree['/german.de.html'],
+                  [tree['/dir2/'], [tree['/dir2/index.en.html'], tree['/dir2/index.de.html']]],
+                  [tree['/dir/'], [[tree['/dir/subfile.html'], [tree['/dir/subfile.html#frag']]],
+                                   [tree['/dir/dir/'], [tree['/dir/dir/file.html']]]]],
+                  [tree['/file.de.html'], [tree['/file.de.html#frag']]],
+                  [tree['/file.en.html'], [[tree['/file.en.html#frag'], [tree['/file.en.html#nested']]]]],
+                 ],
+                 @nf.find({:levels => [2,4], :sort => true, :reverse => true}, tree['/']))
 
     # test filter: meta info keys/values
     check.call(['/file.en.html#frag', '/file.de.html#frag', '/dir/subfile.html#frag'],
@@ -97,6 +110,11 @@ class TestNodeFinder < MiniTest::Unit::TestCase
                @nf.find({:absolute_levels => [0, 0], :flatten => true}, tree['/dir/']))
     check.call(%w[/file.en.html#nested /dir/subfile.html#frag /dir/dir/file.html],
                @nf.find({:absolute_levels => [3,3], :flatten => true}, tree['/dir/']))
+    check.call(%w[/file.en.html#frag /file.en.html#nested /file.de.html#frag /dir/subfile.html
+                  /dir/subfile.html#frag /dir/dir/ /dir/dir/file.html /dir2/index.en.html /dir2/index.de.html],
+               @nf.find({:absolute_levels => [2,-1], :flatten => true}, tree['/dir/dir/file.html']))
+    check.call(%w[/file.en.html#frag /file.de.html#frag /dir/subfile.html /dir/dir/ /dir2/index.en.html /dir2/index.de.html],
+               @nf.find({:absolute_levels => [2,-2], :flatten => true}, tree['/dir/dir/file.html']))
     check.call(%w[/ /file.en.html /file.de.html /other.html /other.en.html /german.de.html /dir/ /dir2/],
                @nf.find({:absolute_levels => [0,1], :flatten => true}, tree['/dir/']))
     check.call(%w[/],
@@ -110,7 +128,7 @@ class TestNodeFinder < MiniTest::Unit::TestCase
     check.call(%w[/file.en.html /file.de.html /other.en.html /german.de.html /dir2/index.en.html /dir2/index.de.html],
                @nf.find({:lang => ['en', 'de'], :flatten => true}, tree['/dir/']))
     check.call(%w[/file.en.html /other.en.html /dir2/index.en.html],
-               @nf.find({:lang => :node, :flatten => true}, tree['/file.en.html']))
+               @nf.find({:lang => 'node', :flatten => true}, tree['/file.en.html']))
 
     # test filter: ancestors
     check.call(%w[/ /dir/ /dir/dir/ /dir/dir/file.html],
@@ -125,6 +143,16 @@ class TestNodeFinder < MiniTest::Unit::TestCase
     # test filter: siblings
     check.call(%w[/file.en.html /file.de.html /other.html /other.en.html /german.de.html /dir/ /dir2/],
                @nf.find({:siblings => true, :flatten => true}, tree['/dir/']))
+    check.call(%w[/dir/subfile.html /dir/dir/ /dir/dir/file.html],
+               @nf.find({:siblings => [2, 3], :flatten => true}, tree['/dir/dir/file.html']))
+    check.call(%w[/dir/subfile.html /dir/dir/ /dir/dir/file.html],
+               @nf.find({:siblings => [2, -1], :flatten => true}, tree['/dir/dir/file.html']))
+    check.call(%w[/file.en.html /file.de.html /other.html /other.en.html /german.de.html
+                  /dir/ /dir/subfile.html /dir/dir/ /dir/dir/file.html /dir2/],
+               @nf.find({:siblings => [1, 5], :flatten => true}, tree['/dir/dir/file.html']))
+    check.call(%w[/ /file.en.html /file.de.html /other.html /other.en.html /german.de.html
+                  /dir/ /dir/subfile.html /dir/dir/ /dir2/],
+               @nf.find({:siblings => [0, 2], :flatten => true}, tree['/dir/dir/file.html']))
 
   end