webgen 0.5.8 → 0.5.9

data/test/test_common_sitemap.rb

@@ -17,7 +17,7 @@ class TestCommonSitemap < Test::Unit::TestCase
   end
 
   def do_assert(node, lang, honor_in_menu, any_lang, used_kinds, result)
-    assert_equal(result.map {|name| @nodes[name].absolute_lcn },
+    assert_equal(result.map {|name| @nodes[name].alcn },
                  @obj.create_sitemap(node, lang, {
                                        'common.sitemap.honor_in_menu' => honor_in_menu,
                                        'common.sitemap.any_lang' => any_lang,

data/test/test_contentprocessor.rb

@@ -10,7 +10,7 @@ class TestContentProcessor < Test::Unit::TestCase
 
   def setup
     super
-    @website.config.data['contentprocessor.map'] = {'test' => Hash}
+    @website.config.data['contentprocessor.map'] = {'test' => Hash, 'binary' => [Hash, :binary]}
   end
 
   def test_access_hash
@@ -22,12 +22,18 @@ class TestContentProcessor < Test::Unit::TestCase
   end
 
   def test_list
-    assert_equal(['test'], Webgen::ContentProcessor.list)
+    assert_equal(['binary', 'test'], Webgen::ContentProcessor.list.sort)
   end
 
   def test_for_name
     assert_kind_of(Hash, Webgen::ContentProcessor.for_name('test'))
+    assert_kind_of(Hash, Webgen::ContentProcessor.for_name('binary'))
     assert_nil(Webgen::ContentProcessor.for_name('other'))
   end
 
+  def test_is_binary
+    assert(!Webgen::ContentProcessor.is_binary?('test'))
+    assert(Webgen::ContentProcessor.is_binary?('binary'))
+  end
+
 end

data/test/test_contentprocessor_blocks.rb

@@ -1,13 +1,16 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/page'
 require 'webgen/contentprocessor'
 
 class TestContentProcessorBlocks < Test::Unit::TestCase
 
-  def test_process
+  include Test::WebsiteHelper
+
+  def test_call_and_render_node
     obj = Webgen::ContentProcessor::Blocks.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
@@ -20,28 +23,31 @@ class TestContentProcessorBlocks < Test::Unit::TestCase
     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])
+    assert_equal(Set.new([node.alcn, template.alcn]), 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 = "\nsadfasdf<webgen:block name='nothing'/>"
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
+
+    context.content = '<webgen:block name="content" chain="invalid" />'
+    assert_error_on_line(Webgen::RenderError, 1) { obj.call(context) }
 
-    context.content = '<webgen:block name="content" chain="invalid" /><webgen:block name="content" />'
+    context.content = '<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])
+    assert_equal('beforedataafter', context.content)
+    assert_equal(Set.new([template.alcn, node.alcn]), 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) }
+    assert_error_on_line(Webgen::RenderError, 1) { obj.call(context) }
 
     context.content = '<webgen:block name="other" chain="template;test" node="first" />'
     obj.call(context)
@@ -63,6 +69,9 @@ class TestContentProcessorBlocks < Test::Unit::TestCase
     context.content = '<webgen:block name="other" node="current" chain="template"/>'
     obj.call(context)
     assert_equal('other', context.content)
+
+    assert_equal('other', obj.render_block(context, :chain => [template], :name => 'other', :node => 'current'))
+    assert_equal('beforedataafter', obj.render_block(context, :chain => [template, node], :name => 'content', :node => 'first'))
   end
 
 end

data/test/test_contentprocessor_builder.rb

@@ -1,23 +1,34 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
 class TestContentProcessorBuilder < Test::Unit::TestCase
 
+  include Test::WebgenAssertions
+
   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 => context.node.absolute_lcn) { xml.strong('test'); " +
+    content = "xml.div(:path => context.node.alcn) { xml.strong('test'); " +
       "context.website; context; context.ref_node; context.dest_node }"
     context = Webgen::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 }
+
+    context.content = "xml.div do \n5+5\n+=+6\nend"
+    assert_error_on_line(Webgen::RenderError, 3) { obj.call(context) }
+
+    context.content = "xml.div do \n5+5\nunknown\n++6\nend"
+    assert_error_on_line(Webgen::RenderError, 3) { obj.call(context) }
+
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_erb.rb

@@ -1,23 +1,29 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
 class TestContentProcessorErb < Test::Unit::TestCase
 
+  include Test::WebgenAssertions
+
   def test_call
     obj = Webgen::ContentProcessor::Erb.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
-    content = "<%= context[:doit] %>6\n<%= context.ref_node.absolute_lcn %>\n<%= context.node.absolute_lcn %>\n<%= context.dest_node.absolute_lcn %><% website %>"
+    content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% website %>"
     context = Webgen::Context.new(:content => content, :doit => 'hallo',
                                                     :chain => [node])
     obj.call(context)
     assert_equal("hallo6\n/test\n/test\n/test", context.content)
 
-    context.content = '<%= 5* %>'
-    assert_raise(RuntimeError) { obj.call(context) }
+    context.content = "\n<%= 5* %>"
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
+
+    context.content = "\n\n<% unknown %>"
+    assert_error_on_line(Webgen::RenderError, 3) { obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_erubis.rb

@@ -17,11 +17,14 @@ class TestContentProcessorErubis < Test::Unit::TestCase
     node = Webgen::Node.new(root, 'test', 'test')
     context = Webgen::Context.new(:doit => 'hallo', :chain => [node])
 
-    context.content = "<%= context[:doit] %>6\n<%= context.ref_node.absolute_lcn %>\n<%= context.node.absolute_lcn %>\n<%= context.dest_node.absolute_lcn %><% context.website %>"
+    context.content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% context.website %>"
     assert_equal("hallo6\n/test\n/test\n/test", obj.call(context).content)
 
-    context.content = '<%= 5* %>'
-    assert_raise(RuntimeError) { obj.call(context) }
+    context.content = "\n<%= 5* %>"
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
+
+    context.content = "\n\n<% unknown %>"
+    assert_error_on_line(Webgen::RenderError, 3) { obj.call(context) }
 
     context.content = "<% for i in [1] %>\n<%= i %>\n<% end %>"
     assert_equal("1\n", obj.call(context).content)
@@ -44,6 +47,9 @@ class TestContentProcessorErubis < Test::Unit::TestCase
 
     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)
+
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_fragments.rb

@@ -13,30 +13,31 @@ class TestContentProcessorFragments < Test::Unit::TestCase
   def test_process
     Webgen::SourceHandler::Main.new
     @website.blackboard.del_service(:source_paths)
-    @website.blackboard.add_service(:source_paths) { Hash.new(path_with_meta_info('/')) }
+    @website.blackboard.add_service(:source_paths) { Hash.new(path_with_meta_info('/test.html')) }
 
     obj = Webgen::ContentProcessor::Fragments.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
-    root.node_info[:src] = '/'
+    node = Webgen::Node.new(root, '/test.html', 'test.html')
+    node.node_info[:src] = '/test.html'
     processors = { 'fragments' => obj }
 
-    context = Webgen::Context.new(:chain => [root], :processors => processors)
+    context = Webgen::Context.new(:chain => [node], :processors => processors)
     context.content = '<h1 id="test">Test</h1><h1>Test2</h1>'
     obj.call(context)
-    assert(root.tree['/#test'])
-    assert_equal(3, root.tree.node_access[:alcn].length)
-    root.tree.delete_node('/#test')
+    assert(root.tree['/test.html#test'])
+    assert_equal(4, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/test.html#test')
 
     context[:block] = Webgen::Page::Block.new('content', '', {})
     obj.call(context)
-    assert(root.tree['/#test'])
-    assert_equal(3, root.tree.node_access[:alcn].length)
-    root.tree.delete_node('/#test')
+    assert(root.tree['/test.html#test'])
+    assert_equal(4, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/test.html#test')
 
     context[:block] = Webgen::Page::Block.new('other', '', {})
     obj.call(context)
-    assert(!root.tree['/#test'])
-    assert_equal(2, root.tree.node_access[:alcn].length)
+    assert(!root.tree['/test.html#test'])
+    assert_equal(3, root.tree.node_access[:alcn].length)
   end
 
 end

data/test/test_contentprocessor_haml.rb

@@ -1,23 +1,32 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
 class TestContentProcessorHaml < Test::Unit::TestCase
 
+  include Test::WebgenAssertions
+
   def test_call
     obj = Webgen::ContentProcessor::Haml.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
-    content = "#content\n  %h1 Hallo\n  = [context.node.absolute_lcn, context.ref_node.absolute_lcn, context.dest_node.absolute_lcn, context.website, context.dest_node.absolute_lcn].join"
+    content = "#content\n  %h1 Hallo\n  = [context.node.alcn, context.ref_node.alcn, context.dest_node.alcn, context.website, context.dest_node.alcn].join"
     context = Webgen::Context.new(:content => content,
                                                     :chain => [node])
     obj.call(context)
     assert_equal("<div id='content'>\n  <h1>Hallo</h1>\n  /test/test/test/test\n</div>\n", context.content)
 
+    context.content = "#cont\n    %unknown"
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
+
     context.content = "#cont\n  = unknown"
-    assert_raise(RuntimeError) { obj.call(context) }
+    assert_raise(Webgen::RenderError) { obj.call(context) }
+
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_head.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/page'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorHead < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_call
+    obj = Webgen::ContentProcessor::Head.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test', {'meta' => {'other' => 'me'}})
+
+    context = Webgen::Context.new(:chain => [node])
+    context.content = '</head>'
+    obj.call(context)
+    assert_equal("\n<meta name=\"other\" content=\"me\" /></head>", context.content)
+
+    context.content = '</head>'
+    context.clone.persistent[:cp_head] = {
+      :js_file => ['hallo.js', 'hallo2.js', 'hallo.js'],
+      :js_inline => ["somescript", "anotherscript"],
+      :css_file => ['hallo.css', 'hallo2.css', 'hallo.css'],
+      :css_inline => ["somestyle", "anotherstyle"],
+      :meta => {:lucky => 'me<"'}
+    }
+    node['meta'].clear
+    obj.call(context)
+    assert_equal("\n<script type=\"text/javascript\" src=\"hallo.js\"></script>" +
+                 "\n<script type=\"text/javascript\" src=\"hallo2.js\"></script>" +
+                 "\n<script type=\"text/javascript\">\nsomescript\n</script>" +
+                 "\n<script type=\"text/javascript\">\nanotherscript\n</script>" +
+                 "\n<link rel=\"stylesheet\" href=\"hallo.css\" type=\"text/css\"/>" +
+                 "\n<link rel=\"stylesheet\" href=\"hallo2.css\" type=\"text/css\"/>" +
+                 "\n<style type=\"text/css\"><![CDATA[/\nsomestyle\n]]></style>" +
+                 "\n<style type=\"text/css\"><![CDATA[/\nanotherstyle\n]]></style>" +
+                 "\n<meta name=\"lucky\" content=\"me&lt;&quot;\" /></head>", context.content)
+  end
+
+end

data/test/test_contentprocessor_maruku.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/node'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
@@ -14,7 +15,10 @@ class TestContentProcessorMaruku < Test::Unit::TestCase
     assert_equal('<h1 id=\'header\'>header</h1>', @obj.call(context).content)
 
     context.content = "# head*d* {#das .dsaf "
-    assert_raise(RuntimeError) { @obj.call(context)}
+    assert_raise(Webgen::RenderError) { @obj.call(context)}
+
+    def @obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { @obj.call(context) }
   end
 
   def test_call_fix_for_invalid_id

data/test/test_contentprocessor_rdiscount.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/node'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
@@ -12,6 +13,9 @@ class TestContentProcessorRDiscount < Test::Unit::TestCase
     node = Webgen::Node.new(Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/'), 'test', 'test')
     context = Webgen::Context.new(:content => '# header', :chain => [node])
     assert_equal("<h1>header</h1>\n", @obj.call(context).content)
+
+    def @obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { @obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_rdoc.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
@@ -13,6 +14,9 @@ class TestContentProcessorRDoc < Test::Unit::TestCase
     context = Webgen::Context.new(:content => "* hello",
                                                     :chain => [node])
     assert_equal("<ul>\n<li>hello\n\n</li>\n</ul>\n", obj.call(context).content)
+
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_redcloth.rb

@@ -11,12 +11,16 @@ class TestContentProcessorRedCloth < Test::Unit::TestCase
 
   def test_call
     @obj = Webgen::ContentProcessor::RedCloth.new
-    context = Webgen::Context.new(:content => "h1. header\n\nthis\nis\nsome\ntext")
+    node = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    context = Webgen::Context.new(:content => "h1. header\n\nthis\nis\nsome\ntext", :chain => [node])
     assert_equal("<h1>header</h1>\n<p>this\nis\nsome\ntext</p>", @obj.call(context).content)
 
     context.content = "h1. header\n\nthis\nis\nsome\ntext"
     @website.config['contentprocessor.redcloth.hard_breaks'] = true
     assert_equal("<h1>header</h1>\n<p>this<br />\nis<br />\nsome<br />\ntext</p>", @obj.call(context).content)
+
+    def @obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { @obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_sass.rb

@@ -1,11 +1,14 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
+require 'helper'
 require 'webgen/tree'
 require 'webgen/contentprocessor'
 
 class TestContentProcessorSass < Test::Unit::TestCase
 
+  include Test::WebgenAssertions
+
   def test_call
     obj = Webgen::ContentProcessor::Sass.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
@@ -15,8 +18,11 @@ class TestContentProcessorSass < Test::Unit::TestCase
     obj.call(context)
     assert_equal("#main {\n  background-color: #000; }\n", context.content)
 
-    context.content = "#cont \n = unknown"
-    assert_raise(RuntimeError) { obj.call(context) }
+    context.content = "#cont\n = 5"
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
+
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
   end
 
 end

data/test/test_contentprocessor_tags.rb

@@ -15,6 +15,8 @@ class TestContentProcessorTags < Test::Unit::TestCase
 
     def create_tag_params(*args); end
 
+    def create_params_hash(*args); end
+
     def call(tag, body, context)
       case tag
       when 'body'
@@ -36,9 +38,6 @@ class TestContentProcessorTags < Test::Unit::TestCase
 
   def test_call
     context = Webgen::Context.new(:chain => [Webgen::Tree.new.dummy_root])
-    context.content = "{test: }"
-    assert_equal('', @obj.call(context).content)
-
     add_test_tag
     assert_equal('test', @obj.call(context.clone(:content => "{test: }")).content)
     assert_equal('thebody', @obj.call(context.clone(:content => "{body::}thebody{body}")).content)
@@ -46,13 +45,24 @@ class TestContentProcessorTags < Test::Unit::TestCase
                   @obj.call(context.clone(:content => "test{bodyproc::} \\{other:}{other:} {bodyproc}test")).content)
   end
 
+  def test_process_tag
+    context = Webgen::Context.new(:chain => [Webgen::Tree.new.dummy_root])
+    context.content = "\n{test: }"
+    assert_error_on_line(Webgen::RenderError, 2) { @obj.call(context) }
+
+    add_test_tag
+    assert_equal('test', @obj.process_tag('test', {'something' => 'new'}, '', context))
+    assert_equal('test', @obj.process_tag('test', '{something: new}', '', context))
+    assert_equal('thebody', @obj.process_tag('body', '{something: new}', 'thebody', context))
+  end
+
   def test_replace_tags
     check_returned_tags('sdfsdf{asd', [])
     check_returned_tags('sdfsdf}asd', [])
     check_returned_tags('sdfsdf{asd}', [])
-    check_returned_tags('sdfsdf{asd: {}as', [])
+    check_returned_tags('sdfsdf{asd: {}as', [], true)
     check_returned_tags('sdfsdf{test: {test1: }}', [['test', ' {test1: }', '']], 'sdfsdftest1')
-    check_returned_tags('sdfsdf{test: {test1: {}}', [['test', '', '']], 'sdfsdf{test: {test1: {}}')
+    check_returned_tags('sdfsdf{test: {test1: {}}', [], true)
     check_returned_tags('sdfsdf{test:}{test1: }', [['test', '', ''], ['test1', ' ', '']], 'sdfsdftest1test2')
     check_returned_tags('sdfsdf{test:}\\{test1: }', [['test', '', '']], "sdfsdftest1{test1: }")
     check_returned_tags('sdfsdf\\{test:}{test1:}', [['test1', '', '']], "sdfsdf{test:}test1")
@@ -62,7 +72,7 @@ class TestContentProcessorTags < Test::Unit::TestCase
     check_returned_tags('sdfsdf\\\\\\{test: asdf}sdf', [['test', ' asdf', '']], "sdfsdf\\{test: asdf}sdf")
 
     check_returned_tags('before{test::}body{test}', [['test', '', 'body']], "beforetest1")
-    check_returned_tags('before{test::}body{testno}', [], "before{test::}body{testno}")
+    check_returned_tags('before{test::}body{testno}', [], true)
     check_returned_tags('before{test::}body\\{test}other{test}', [['test', '', 'body{test}other']], "beforetest1")
     check_returned_tags('before{test::}body\\{test}{test}', [['test', '', 'body{test}']], "beforetest1")
     check_returned_tags('before{test::}body\\{test}\\\\{test}after', [['test', '', 'body{test}\\']], "beforetest1after")
@@ -92,7 +102,12 @@ class TestContentProcessorTags < Test::Unit::TestCase
       i += 1
       'test' + i.to_s
     end
-    assert_equal(result, @obj.instance_eval { replace_tags(content, Webgen::Tree.new.dummy_root, &check_proc) })
+    context = Webgen::Context.new(:chain => [Webgen::Tree.new.dummy_root], :content => content)
+    if result.kind_of?(TrueClass)
+      assert_error_on_line(Webgen::RenderError, 1) { @obj.send(:replace_tags, context, &check_proc) }
+    else
+      assert_equal(result, @obj.instance_eval { replace_tags(context, &check_proc) })
+    end
     assert(i, data.length)
   end