thewoolleyman-webgen 0.5.8.20090419

data/test/test_contentprocessor_context.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/contentprocessor'
+
+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,23 @@
+# -*- encoding: utf-8 -*-
+
+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')
+    content = "<%= context[:doit] %>6\n<%= ref_node.absolute_lcn %>\n<%= node.absolute_lcn %>\n<%= dest_node.absolute_lcn %><% website %>"
+    context = Webgen::ContentProcessor::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) }
+  end
+
+end

data/test/test_contentprocessor_erubis.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+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\n<%= ref_node.absolute_lcn %>\n<%= node.absolute_lcn %>\n<%= dest_node.absolute_lcn %><% 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 = "<% 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

data/test/test_contentprocessor_fragments.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'test/helper'
+require 'webgen/page'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorFragments < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  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('/')) }
+
+    obj = Webgen::ContentProcessor::Fragments.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    root.node_info[:src] = '/'
+    processors = { 'fragments' => obj }
+
+    context = Webgen::ContentProcessor::Context.new(:chain => [root], :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')
+
+    context[:block] = Webgen::Block.new('content', '', {})
+    obj.call(context)
+    assert(root.tree['/#test'])
+    assert_equal(3, root.tree.node_access[:alcn].length)
+    root.tree.delete_node('/#test')
+
+    context[:block] = Webgen::Block.new('other', '', {})
+    obj.call(context)
+    assert(!root.tree['/#test'])
+    assert_equal(2, root.tree.node_access[:alcn].length)
+  end
+
+end

data/test/test_contentprocessor_haml.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorHaml < Test::Unit::TestCase
+
+  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  = [node.absolute_lcn, ref_node.absolute_lcn, dest_node.absolute_lcn, website, context.dest_node.absolute_lcn].join"
+    context = Webgen::ContentProcessor::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_raise(RuntimeError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_maruku.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/node'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorMaruku < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::ContentProcessor::Maruku.new
+    node = Webgen::Node.new(Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/'), 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => '# header', :chain => [node])
+    assert_equal('<h1 id=\'header\'>header</h1>', @obj.call(context).content)
+
+    context.content = "# head*d* {#das .dsaf "
+    assert_raise(RuntimeError) { @obj.call(context)}
+  end
+
+  def test_call_fix_for_invalid_id
+    @obj = Webgen::ContentProcessor::Maruku.new
+    context = Webgen::ContentProcessor::Context.new(:content => '# `test`')
+    assert_equal('<h1 id=\'id1\'><code>test</code></h1>', @obj.call(context).content)
+
+    context = Webgen::ContentProcessor::Context.new(:content => '# `test`')
+    assert_equal('<h1 id=\'id1\'><code>test</code></h1>', @obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_rdiscount.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/node'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorRDiscount < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::ContentProcessor::RDiscount.new
+    node = Webgen::Node.new(Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/'), 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => '# header', :chain => [node])
+    assert_equal("<h1>header</h1>\n", @obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_rdoc.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorRDoc < Test::Unit::TestCase
+
+  def test_call
+    obj = Webgen::ContentProcessor::RDoc.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => "* hello",
+                                                    :chain => [node])
+    assert_equal("<ul>\n<li>hello\n\n</li>\n</ul>\n", obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_redcloth.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/websiteaccess'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorRedCloth < Test::Unit::TestCase
+
+  def test_call
+    @obj = Webgen::ContentProcessor::RedCloth.new
+    context = Webgen::ContentProcessor::Context.new(:content => 'h1. header')
+    assert_equal('<h1>header</h1>', @obj.call(context).content)
+  end
+
+end

data/test/test_contentprocessor_sass.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorSass < Test::Unit::TestCase
+
+  def test_call
+    obj = Webgen::ContentProcessor::Sass.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::ContentProcessor::Context.new(:content => "#main\n  :background-color #000",
+                                                    :chain => [node])
+    obj.call(context)
+    assert_equal("#main {\n  background-color: #000; }\n", context.content)
+
+    context.content = "#cont \n = unknown"
+    assert_raise(RuntimeError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_tags.rb

@@ -0,0 +1,99 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorTags < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  class TestTag
+
+    def set_params(*args); end
+
+    def create_tag_params(*args); end
+
+    def call(tag, body, context)
+      case tag
+      when 'body'
+        body
+      when 'bodyproc'
+        [body, true]
+      else
+        tag
+      end
+    end
+
+  end
+
+  def setup
+    super
+    @obj = Webgen::ContentProcessor::Tags.new
+    @website.config['contentprocessor.tags.map'].delete(:default)
+  end
+
+  def test_call
+    context = Webgen::ContentProcessor::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)
+    assert_equal('test {other:}other test',
+                  @obj.call(context.clone(:content => "test{bodyproc::} \\{other:}{other:} {bodyproc}test")).content)
+  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{test: {test1: }}', [['test', ' {test1: }', '']], 'sdfsdftest1')
+    check_returned_tags('sdfsdf{test: {test1: {}}', [['test', '', '']], 'sdfsdf{test: {test1: {}}')
+    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")
+    check_returned_tags('sdfsdf{test: asdf}', [['test', ' asdf', '']], "sdfsdftest1")
+    check_returned_tags('sdfsdf\\{test: asdf}', [], "sdfsdf{test: asdf}")
+    check_returned_tags('sdfsdf\\\\{test: asdf}', [['test', ' asdf', '']], "sdfsdf\\test1")
+    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\\{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")
+    check_returned_tags('before\\{test::}body{test}', [['test', '', 'body']], "before{test::}body{test}")
+    check_returned_tags('before\\\\{test:: asdf}body{test}after', [['test', ' asdf', 'body']], "before\\test1after")
+  end
+
+  def test_processor_for_tag
+    assert_nil(@obj.instance_eval { processor_for_tag('test') })
+    assert_nil(@obj.instance_eval { processor_for_tag(:default) })
+    add_test_tag
+    assert_not_nil(@obj.instance_eval { processor_for_tag(:default) })
+  end
+
+  private
+
+  def add_test_tag
+    @website.config['contentprocessor.tags.map'].update(:default => 'TestContentProcessorTags::TestTag')
+  end
+
+  def check_returned_tags(content, data, result = content)
+    i = 0
+    check_proc = proc do |tag, params, body|
+      assert_equal(data[i][0], tag, 'tag: ' + content)
+      assert_equal(data[i][1], params, 'params: ' + content)
+      assert_equal(data[i][2], body, 'body: ' + content)
+      i += 1
+      'test' + i.to_s
+    end
+    assert_equal(result, @obj.instance_eval { replace_tags(content, Webgen::Tree.new.dummy_root, &check_proc) })
+    assert(i, data.length)
+  end
+
+end

data/test/test_languages.rb

@@ -0,0 +1,67 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/languages'
+
+class TestLanguages < Test::Unit::TestCase
+
+  def test_get_language
+    assert_nil(Webgen::LanguageManager.language_for_code(nil))
+
+    lang1 = Webgen::LanguageManager.language_for_code('ger')
+    lang2 = Webgen::LanguageManager.language_for_code('deu')
+    lang3 = Webgen::LanguageManager.language_for_code('de')
+    lang4 = Webgen::LanguageManager.language_for_code('en')
+
+    [lang1, lang2, lang3, lang4].each {|lang| assert_kind_of(Webgen::Language, lang)}
+    assert_equal(lang1, lang2)
+    assert_equal(lang3, lang2)
+    assert_not_equal(lang4, lang2)
+  end
+
+  def test_find_language
+    langs = Webgen::LanguageManager.find_language('greek')
+    assert_equal(2, langs.length)
+    assert_equal('gre', langs[0].code3chars)
+    assert_equal('grc', langs[1].code3chars)
+  end
+
+  def test_language_accessors
+    lang = Webgen::LanguageManager.language_for_code('ger')
+    assert_equal('ger', lang.code3chars)
+    assert_equal('deu', lang.code3chars_alternative)
+    assert_equal('de', lang.code2chars)
+  end
+
+  def test_other_methods
+    de = Webgen::LanguageManager.language_for_code('ger')
+    assert_equal('de', de)
+    assert_equal(de, 'de')
+    assert_equal("de", de.to_s)
+    assert_equal("Implicitly de", "Implicitly " + de)
+    assert_kind_of(String, de.inspect)
+  end
+
+  def test_sort_method
+    ger = Webgen::LanguageManager.language_for_code('ger')
+    eng = Webgen::LanguageManager.language_for_code('en')
+    ace = Webgen::LanguageManager.language_for_code('ace')
+
+    assert_equal(-1, ger <=> eng)
+    assert_equal(-1, ace <=> ger)
+    assert_equal(-1, ace <=> eng)
+  end
+
+  def test_hashing
+    de = Webgen::LanguageManager.language_for_code('ger')
+    en = Webgen::LanguageManager.language_for_code('en')
+    h = {'de' => de, en => en}
+    assert_equal(de, h[de])
+    assert_equal(de, h['de'])
+    assert_equal(en, h[en])
+    assert_not_equal(en, h['en']) # bc 'en'.eql?(en) is false
+    assert_equal(Webgen::LanguageManager.language_for_code('en'),
+                 Webgen::LanguageManager.language_for_code(en))
+  end
+
+end