webgen 0.5.17 → 1.0.0.beta1

data/test/test_contentprocessor_tags.rb

@@ -1,122 +0,0 @@
-# -*- 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 create_params_hash(*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::Context.new(:chain => [Webgen::Tree.new.dummy_root])
-    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_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', [], true)
-    check_returned_tags('sdfsdf{test: {test1: }}', [['test', ' {test1: }', '']], 'sdfsdftest1')
-    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")
-    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}', [], 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")
-    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")
-
-    check_returned_tags('sdfsüdf{test: }', [['test', ' ', '']], "sdfsüdftest1")
-    check_returned_tags('sdfsüüdf{test: asdf}', [['test', ' asdf', '']], "sdfsüüdftest1")
-    check_returned_tags('sdfsüüdf{test: asüdf}a', [['test', ' asüdf', '']], "sdfsüüdftest1a")
-    check_returned_tags('sdfsüüdf\\{test: asdf}ab', [], "sdfsüüdf{test: asdf}ab")
-    check_returned_tags('sdfsüüdf\\\\{test: asdf}ab', [['test', ' asdf', '']], "sdfsüüdf\\test1ab")
-    check_returned_tags('sdfsüüdf\\\\\\{test: asdf}ab', [], "sdfsüüdf\\{test: asdf}ab")
-    check_returned_tags('sdfsüüdf{test:: asdf}abü{test}ab', [['test', ' asdf', 'abü']], "sdfsüüdftest1ab")
-  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
-    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
-
-end

data/test/test_contentprocessor_tidy.rb

@@ -1,34 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'helper'
-require 'webgen/contentprocessor'
-
-class TestContentProcessorTidy < Test::Unit::TestCase
-
-  include Test::WebsiteHelper
-
-  def test_call
-    obj = Webgen::ContentProcessor::Tidy.new
-    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
-    node = Webgen::Node.new(root, '/test', 'test')
-    context = Webgen::Context.new(:content => "testcontent", :chain => [node])
-
-    tmp, ENV['PATH'] = ENV['PATH'], '/sbin'
-    assert_raise(Webgen::CommandNotFoundError) { obj.call(context) }
-    ENV['PATH'] = tmp
-
-    output = StringIO.new('')
-    @website.logger = ::Logger.new(output)
-    @website.logger.level = Logger::WARN
-
-    assert_match(/html.*testcontent/im, obj.call(context).content)
-    output.rewind; assert_match(/inserting missing/, output.read)
-
-    output.string = ''
-    context.content = '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN"><html><head><title>t</title></head><body>b</body></html'
-    assert_match(/body.*b.*body/im, obj.call(context).content)
-    assert_equal(0, output.string.length)
-  end
-
-end

data/test/test_contentprocessor_xmllint.rb

@@ -1,38 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'helper'
-require 'webgen/contentprocessor'
-
-class TestContentProcessorXmllint < Test::Unit::TestCase
-
-  include Test::WebsiteHelper
-
-  def test_call
-    obj = Webgen::ContentProcessor::Xmllint.new
-    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
-    node = Webgen::Node.new(root, '/test', 'test')
-    context = Webgen::Context.new(:content => "", :chain => [node])
-
-    tmp, ENV['PATH'] = ENV['PATH'], '/sbin'
-    assert_raise(Webgen::CommandNotFoundError) { obj.call(context) }
-    ENV['PATH'] = tmp
-
-    output = StringIO.new('')
-    @website.logger = ::Logger.new(output)
-    @website.logger.level = Logger::WARN
-
-    context.content = data = 'test'
-    obj.call(context)
-    assert_equal(data, context.content)
-    output.rewind; assert_match(/<\/test:~1>/, output.read)
-
-    output.string = ''
-    context.content = data = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' +
-      '<html xmlns="http://www.w3.org/1999/xhtml"><head><title>title</title></head><body></body></html>'
-    obj.call(context)
-    assert_equal(data, context.content)
-    assert_equal(0, output.string.length)
-  end
-
-end

data/test/test_context.rb

@@ -1,81 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'helper'
-require 'webgen/context'
-
-class TestContext < Test::Unit::TestCase
-
-  include Test::WebsiteHelper
-
-  def setup
-    super
-    @context = Webgen::Context.new(:content => 'test', :key => :value, :chain => [:first, :last])
-  end
-
-  def test_initialize
-    context = Webgen::Context.new
-    assert_equal('', context.content)
-    assert_equal({}, context.persistent)
-    assert_kind_of(Webgen::ContentProcessor::AccessHash, context[:processors])
-
-    context = Webgen::Context.new(:content => 'test', :key => :value)
-    assert_equal('test', context.content)
-    assert_equal(:value, context[:key])
-    assert_equal({}, context.persistent)
-
-    context = Webgen::Context.new({:content => 'test', :key => :value}, {:other => :val})
-    assert_equal('test', context.content)
-    assert_equal(:value, context[:key])
-    assert_equal({:other => :val}, context.persistent)
-  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)
-    @context[:key] = :newvalue
-    assert_equal(:newvalue, @context[:key])
-  end
-
-  def test_node_methods
-    assert_equal(:first, @context.ref_node)
-    assert_equal(:last, @context.content_node)
-    assert_equal(:last, @context.dest_node)
-    @context[:dest_node] = :other
-    assert_equal(:other, @context.dest_node)
-  end
-
-  def test_tags_methods
-    @context[:chain] = [Webgen::Tree.new.dummy_root]
-
-    klass = Class.new do
-      def set_params(*args); end
-      def create_tag_params(*args); end
-      def create_params_hash(*args); end
-      def call(tag, body, context); 'mivalue'; end
-    end
-    (@website.cache.volatile[:classes] ||= {})['TestTag'] = klass.new
-    @website.config['contentprocessor.tags.map'].update(:default => 'TestTag')
-
-    assert_equal('mivalue', @context.tag('mivalue'))
-  end
-
-  def test_render_methods
-    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
-    node = Webgen::Node.new(root, 'test', 'test')
-    node.node_info[:page] = Webgen::Page.from_data("--- name:content\ndata\n--- name:other\nother")
-    @context[:chain] = [root, node]
-
-    assert_equal('data', @context.render_block('content'))
-    assert_equal('other', @context.render_block(:name => 'other'))
-  end
-
-end

data/test/test_error.rb

@@ -1,93 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'webgen/tree'
-require 'webgen/node'
-require 'webgen/error'
-
-class TestError < Test::Unit::TestCase
-
-  def test_all
-    e = Webgen::Error.new("test")
-    assert_equal("test", e.plain_message)
-    assert_match(/Error while working:/, e.message)
-
-    e = Webgen::Error.new("test", 'KlassName')
-    assert_equal("test", e.plain_message)
-    assert_equal('KlassName', e.class_name)
-    assert_match(/Error while working with KlassName:/, e.message)
-
-    e = Webgen::Error.new("test", 'KlassName', '/path')
-    assert_equal("test", e.plain_message)
-    assert_equal('KlassName', e.class_name)
-    assert_equal('/path', e.alcn)
-    assert_match(/Error while working on <\/path> with KlassName:/, e.message)
-
-    e = Webgen::Error.new("test", 'KlassName', Webgen::Node.new(Webgen::Tree.new.dummy_root, '/hallo', '/hallo'))
-    assert_equal('/hallo', e.alcn)
-
-    e = Webgen::Error.new(Exception.new("test"))
-    assert_equal("test", e.plain_message)
-    assert_match(/Error while working:/, e.message)
-  end
-
-end
-
-class TestNodeCreationError < Test::Unit::TestCase
-
-  def test_all
-    e = Webgen::NodeCreationError.new("test")
-    assert_equal("test", e.plain_message)
-    assert_match(/Error while creating a node:/, e.message)
-  end
-
-end
-
-class TestRenderError < Test::Unit::TestCase
-
-  def test_all
-    e = Webgen::RenderError.new("test", 'KlassName', '/path', '/error')
-    assert_equal("/error", e.error_alcn)
-    assert_match(/Error in <\/error> while rendering <\/path>/, e.message)
-
-    e = Webgen::RenderError.new("test", 'KlassName', '/path', '/error', 5)
-    assert_equal("/error", e.error_alcn)
-    assert_match(/Error in <\/error:~5> while rendering <\/path>/, e.message)
-
-    e = Webgen::RenderError.new("test", 'KlassName', '/path', Webgen::Node.new(Webgen::Tree.new.dummy_root, '/hallo', '/hallo'), 5)
-    assert_equal('/hallo', e.error_alcn)
-  end
-
-end
-
-class TestLoadError < Test::Unit::TestCase
-
-  def test_all
-    e = Webgen::LoadError.new(Exception.new("something"), 'KlassName', '/path')
-    assert_nil(e.library)
-    assert_nil(e.gem)
-    assert_match(/Error while working on <\/path> with KlassName:.*something/m, e.message)
-
-    e = Webgen::LoadError.new("test", 'KlassName', '/path')
-    assert_equal("test", e.library)
-    assert_nil(e.gem)
-    assert_match(/Error while working on <\/path> with KlassName:.*The needed library 'test' is missing/m, e.message)
-
-    e = Webgen::LoadError.new("test", 'KlassName', '/path', 'gem')
-    assert_equal("test", e.library)
-    assert_equal('gem', e.gem)
-    assert_match(/Error while working on <\/path> with KlassName:.*The needed library 'test' is missing.*gem install gem/m, e.message)
-  end
-
-end
-
-
-class TestCommandNotFoundError < Test::Unit::TestCase
-
-  def test_all
-    e = Webgen::CommandNotFoundError.new("test", 'KlassName', '/path')
-    assert_equal("test", e.cmd)
-    assert_match(/Error while working on <\/path> with KlassName:.*The needed command 'test' is missing/m, e.message)
-  end
-
-end

data/test/test_loggable.rb

@@ -1,32 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'helper'
-require 'webgen/loggable'
-require 'webgen/logger'
-require 'stringio'
-
-class TestLoggable < Test::Unit::TestCase
-
-  include Test::WebsiteHelper
-
-  def setup
-    super
-    @website.logger = Webgen::Logger.new(@io = StringIO.new, true)
-    @obj = Object.new
-    @obj.extend(Webgen::Loggable)
-  end
-
-  def test_log
-    @obj.log(:error) { 'hallo' }
-    assert_equal("ERROR -- hallo\n", @io.string)
-  end
-
-  def test_puts
-    @obj.puts 'test'
-    assert_equal("test\n", @io.string)
-    @obj.puts 'test', :verbose
-    assert_equal("test\n", @io.string)
-  end
-
-end

data/test/test_logger.rb

@@ -1,94 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test/unit'
-require 'helper'
-require 'webgen/logger'
-
-class TestLogger < Test::Unit::TestCase
-
-  def test_initialize
-    l = Webgen::Logger.new(io = StringIO.new)
-    assert_equal(:normal, l.verbosity)
-    assert_equal(::Logger::WARN, l.level)
-    assert_equal(false, l.sync)
-  end
-
-  def test_setters
-    l = Webgen::Logger.new(io = StringIO.new)
-    l.verbosity = :quiet
-    l.level = ::Logger::DEBUG
-    assert_equal(::Logger::DEBUG, l.level)
-    assert_equal(:quiet, l.verbosity)
-  end
-
-  def test_log_sync
-    l = Webgen::Logger.new(io = StringIO.new, true)
-    l.error { 'error' }
-    l.stdout { 'hallo' }
-    l.warn { 'warn' }
-    l.info { 'info' }
-    l.debug { 'debug' }
-    assert_equal("ERROR -- error\nhallo\n WARN -- warn\n", io.string)
-  end
-
-  def test_log_async
-    l = Webgen::Logger.new(io = StringIO.new, false)
-    l.error { 'error' }
-    l.stdout { 'hallo' }
-    assert_equal("hallo\n", io.string)
-  end
-
-  def test_verbosity_levels
-    l = Webgen::Logger.new(io = StringIO.new)
-    l.verbose { 'vrb'}
-    l.stdout { 'std' }
-    assert_equal("std\n", io.string)
-
-    io.string = ''
-    l.verbosity = :verbose
-    l.verbose { 'vrb' }
-    assert_equal("vrb\n", io.string)
-
-    io.string = ''
-    l.verbosity = :quiet
-    l.stdout { 'vrb' }
-    assert_equal("", io.string)
-  end
-
-  def test_debug_format
-    l = Webgen::Logger.new(io = StringIO.new, true)
-    l.level = ::Logger::DEBUG
-    l.info('source') { 'hallo' }
-    assert_equal(" INFO -- source: hallo\n", io.string)
-  end
-
-  def test_log_output
-    l = Webgen::Logger.new(io = StringIO.new, true)
-    l.error { 'hallo' }
-    assert_equal('', l.log_output)
-
-    l = Webgen::Logger.new(io = StringIO.new, false)
-    l.error { 'hallo' }
-    assert_equal("ERROR -- hallo\n", l.log_output)
-  end
-
-  def test_run_marks
-    l = Webgen::Logger.new(io = StringIO.new, true)
-    l.mark_new_cycle
-    l.error { 'hallo' }
-    assert_equal("", l.log_output)
-
-    l = Webgen::Logger.new(io = StringIO.new, false)
-    l.error { 'hallo' }
-    l.mark_new_cycle
-    l.error { 'other' }
-    l.mark_new_cycle
-    assert_equal("ERROR -- hallo\n INFO -- Log messages for run 1 are following\n" +
-                 "ERROR -- other\n INFO -- Log messages for run 2 are following\n", l.log_output)
-
-    l = Webgen::Logger.new(io = StringIO.new, false)
-    l.mark_new_cycle
-    assert_equal("", l.log_output)
-  end
-
-end