thewoolleyman-webgen 0.5.8.20090419

data/test/test_output_filesystem.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/output'
+require 'tmpdir'
+require 'fileutils'
+
+class TestOutputFileSystem < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @website = Webgen::Website.new(File.join(Dir.tmpdir, 'test_webgen'), nil)
+    @website.init
+    Thread.current[:webgen_website] = @website
+  end
+
+  def teardown
+    super
+    FileUtils.rm_rf(File.join(Dir.tmpdir, 'test_webgen'))
+  end
+
+  def test_initialize
+    output = Webgen::Output::FileSystem.new('test')
+    assert_equal(File.join(@website.directory, 'test'), output.root)
+    output = Webgen::Output::FileSystem.new('/tmp/hallo')
+    assert_equal('/tmp/hallo', output.root)
+    output = Webgen::Output::FileSystem.new('../hallo')
+    assert_equal(File.join(@website.directory, '../hallo'), output.root)
+  end
+
+  def test_file_methods
+    output = Webgen::Output::FileSystem.new('test')
+    assert(!output.exists?('/dir/hallo'))
+
+    output.write('/dir/hallo', 'content', :file)
+    assert(File.file?(File.join(output.root, 'dir/hallo')))
+    assert(output.exists?('/dir/hallo'))
+    assert_equal('content', File.read(File.join(output.root, 'dir/hallo')))
+    assert_equal('content', output.read('/dir/hallo'))
+
+    output.delete('/dir/hallo')
+    assert(!output.exists?('/dir/hallo'))
+
+    output.write('/dir/hallo', Webgen::Path::SourceIO.new { StringIO.new('content')}, :file)
+    assert_equal('content', File.read(File.join(output.root, 'dir/hallo')))
+    assert(output.exists?('/dir/hallo'))
+
+    output.delete('/dir')
+    assert(!output.exists?('/dir'))
+
+    output.write('/dir', '', :directory)
+    assert(File.directory?(File.join(output.root, 'dir')))
+
+    assert_raise(RuntimeError) { output.write('other', '', :unknown) }
+  end
+
+end

data/test/test_page.rb

@@ -0,0 +1,214 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/page'
+
+class TestBlock < Test::Unit::TestCase
+
+  def test_render
+    block = Webgen::Block.new('content', 'some content', {'pipeline' => 'test'})
+    context = {:processors => {}}
+    assert_raise(RuntimeError) { block.render(context) }
+    context[:processors]['test'] = lambda {|context| context[:content] = context[:content].reverse + context[:block].name }
+    assert_equal('some content'.reverse + 'content', block.render(context)[:content])
+  end
+
+end
+
+class TestPage < Test::Unit::TestCase
+
+  VALID = <<EOF
+# with more blocks
+- in: |
+    ---
+    key: value
+    ---
+    block1
+    --- 
+      block2  
+    ---  name:block3
+    ---  name:block4
+    yes
+  meta_info: {key: value}
+  blocks:
+    - name: content
+      content: "block1"
+    - name: block2
+      content: "block2"
+    - name: block3
+      content: ''
+    - name: block4
+      content: 'yes'
+
+# empty file
+- in: ""
+  meta_info: {}
+  blocks:
+    - name: content
+      content: ''
+
+# without meta info
+- in: "hallo"
+  meta_info: {}
+  blocks:
+    - name: content
+      content: "hallo"
+
+# with empty block
+- in: |
+    --- 
+    key: value
+
+    ---
+
+  meta_info: {key: value}
+  blocks:
+    - name: content
+      content: ''
+
+# with only meta information, no blocks
+- in: |
+    ---
+    key: value
+
+  meta_info: {key: value}
+  blocks:
+    - name: content
+      content: ''
+
+# block with escaped ---
+- in: |
+    before
+    \\--- in
+    after
+  meta_info: {}
+  blocks:
+    - name: content
+      content: "before\\n--- in\\nafter"
+
+# no meta info, starting with block with name
+- in: |
+    --- name:block1
+  meta_info: {}
+  blocks:
+    - name: block1
+      content: ''
+
+# named block and block with other options
+- in: |
+    --- name:block
+    content doing -
+    with?: with some things
+    --- other:options test1:true test2:false test3:542 pipeline:
+  meta_info: {}
+  blocks:
+    - name: block
+      content: "content doing -\\nwith?: with some things"
+    - name: block2
+      content: ''
+      options: {other: options, test1: true, test2: false, test3: 542, pipeline: ~}
+
+# block with seemingly block start line it
+- in: |
+    --- name:block
+    content
+    ----------- some block start???
+    things
+  meta_info: {}
+  blocks:
+    - name: block
+      content: "content\\n----------- some block start???\\nthings"
+EOF
+
+  INVALID_MI=<<EOF
+# invalid meta info: none specified
+- "---\\n---"
+
+# invalid meta info: no hash
+- |
+  ---
+  doit
+  ---
+  asdf kadsfakl
+
+# invalid meta info: not in yaml format
+- |
+  ---
+  - doit
+  : * [ }
+  ---
+  asdf kadsfakl
+EOF
+
+  INVALID_BLOCKS=<<EOF
+# two blocks with same name
+- |
+  aasdf
+  asdfdf
+  --- name:name
+  asdkf dsaf
+  --- name:name
+  asdf adsf
+
+# invalid format
+- |
+  asdfasd
+  dfdf
+  --- name, incorrect_format
+  lsldf
+EOF
+
+  def test_invalid_pagefiles
+    testdata = YAML::load(INVALID_MI)
+    testdata.each_with_index do |data, index|
+      assert_raise(Webgen::WebgenPageFormatError, "test mi item #{index}") { Webgen::Page.from_data(data) }
+      assert_raise(Webgen::WebgenPageFormatError, "test mi item #{index}") { Webgen::Page.meta_info_from_data(data) }
+    end
+    testdata = YAML::load(INVALID_BLOCKS)
+    testdata.each_with_index do |data, index|
+      assert_raise(Webgen::WebgenPageFormatError, "test blocks item #{index}") { Webgen::Page.from_data(data) }
+    end
+  end
+
+  def test_valid_pagefiles
+    YAML::load(VALID).each_with_index do |data, oindex|
+      mi = Webgen::Page.meta_info_from_data(data['in'])
+      assert_equal(data['meta_info'], mi, "test item #{oindex} - meta info directly")
+      d = Webgen::Page.from_data(data['in'])
+      assert_equal(data['meta_info'], d.meta_info, "test item #{oindex} - meta info all")
+      assert_equal(data['blocks'].length*2, d.blocks.length)
+      data['blocks'].each_with_index do |b, index|
+        index += 1
+        assert_equal(b['name'], d.blocks[index].name, "test item #{oindex} - name")
+        assert_equal(b['content'], d.blocks[index].content, "test item #{oindex} - content")
+        assert_equal(b['options'] || {}, d.blocks[index].options, "test item #{oindex} - options")
+        assert_same(d.blocks[index], d.blocks[b['name']])
+      end
+    end
+  end
+
+  def test_default_values
+    valid = YAML::load(VALID)
+    d = Webgen::Page.from_data(valid[0]['in'], 'blocks' => {1 => { 'name' => 'other1'}, 2 => { 'name' => 'block7'}})
+    assert_equal({'key' => 'value'}, d.meta_info)
+    assert_equal('other1', d.blocks[1].name)
+    assert_equal('block7', d.blocks[2].name)
+  end
+
+  def test_eol_encodings
+    d = Webgen::Page.from_data("---\ntitle: test\r---\r\ncontent")
+    assert_equal({'title' => 'test'}, d.meta_info)
+    assert_equal('content', d.blocks['content'].content)
+  end
+
+  def test_meta_info_dupped
+    mi = {'key' => 'value'}
+    d = Webgen::Page.from_data("---\ntitle: test\n---\ncontent", mi)
+    assert_equal({'title' => 'test', 'key' => 'value'}, d.meta_info)
+    assert_not_same(mi, d.meta_info)
+    d = Webgen::Page.from_data("content", mi)
+    assert_equal({'key' => 'value'}, d.meta_info)
+    assert_not_same(mi, d.meta_info)
+  end
+
+end

data/test/test_path.rb

@@ -0,0 +1,165 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'webgen/path'
+require 'stringio'
+
+class TestPath < Test::Unit::TestCase
+
+  def test_initialize
+    check_proc = proc do |o, path, dir, bn, lang, ext, cn, oi, title|
+      assert_equal(path, o.path)
+      assert_equal(path, o.source_path)
+      assert_equal(dir, o.directory)
+      assert_equal(bn, o.cnbase)
+      assert_equal(lang, o.meta_info['lang'])
+      assert_equal(ext, o.ext)
+      assert_equal(cn, o.cn)
+      assert_equal(oi, o.meta_info['sort_info'])
+      assert_equal(title, o.meta_info['title'])
+    end
+    check_proc.call(Webgen::Path.new('5.base_name-one.de.page'),
+                    '5.base_name-one.de.page', './', 'base_name-one', 'de', 'page', 'base_name-one.page', 5, 'Base name one')
+    check_proc.call(Webgen::Path.new('dir/default.png'),
+                    'dir/default.png', 'dir/', 'default', nil, 'png', 'default.png', nil, 'Default')
+    check_proc.call(Webgen::Path.new('default.en.png'),
+                    'default.en.png', './', 'default', 'en', 'png', 'default.png', nil, 'Default')
+    check_proc.call(Webgen::Path.new('default.deu.png'),
+                    'default.deu.png', './', 'default', 'de', 'png', 'default.png', nil, 'Default')
+    check_proc.call(Webgen::Path.new('default.template'),
+                    'default.template', './', 'default', nil, 'template', 'default.template', nil, 'Default')
+    check_proc.call(Webgen::Path.new('default.en.tar.bz2'),
+                    'default.en.tar.bz2', './', 'default', 'en', 'tar.bz2', 'default.tar.bz2', nil, 'Default')
+    check_proc.call(Webgen::Path.new('default.tar.bz2'),
+                    'default.tar.bz2', './', 'default', nil, 'tar.bz2', 'default.tar.bz2', nil, 'Default')
+    check_proc.call(Webgen::Path.new('default'),
+                    'default', './', 'default', nil, '', 'default', nil, 'Default')
+    check_proc.call(Webgen::Path.new('.htaccess'),
+                    '.htaccess', './', '', nil, 'htaccess', '.htaccess', nil, '')
+
+    check_proc.call(Webgen::Path.new('/'),
+                    '/', '/', '/', nil, '', '/', nil, '/')
+    check_proc.call(Webgen::Path.new('/dir/'),
+                    '/dir/', '/', 'dir', nil, '', 'dir', nil, 'Dir')
+
+    path = Webgen::Path.new('/test/', '/other.path')
+    assert_equal('/other.path', path.source_path)
+    assert_equal('/test/', path.path)
+  end
+
+  def test_mount_at
+    p = Webgen::Path.new('test.de.page')
+    p = p.mount_at('/somedir')
+    assert_equal('/somedir/test.de.page', p.path)
+    assert_equal('/somedir/test.de.page', p.source_path)
+    assert_equal('/somedir/', p.directory)
+
+    p = Webgen::Path.new('/')
+    p = p.mount_at('/somedir')
+    assert_equal('/somedir/', p.path)
+    assert_equal('/somedir/', p.source_path)
+    assert_equal('/', p.directory)
+    assert_equal('somedir', p.cn)
+    assert_equal('Somedir', p.meta_info['title'])
+
+    p = Webgen::Path.new('/source/test.rb')
+    p = p.mount_at('/', '/source/')
+    assert_equal('/test.rb', p.path)
+    assert_equal('/test.rb', p.source_path)
+    assert_equal('/', p.directory)
+    assert_equal('test.rb', p.cn)
+    assert_equal('Test', p.meta_info['title'])
+
+    p = Webgen::Path.new('/source/')
+    p = p.mount_at('/', '/source')
+    assert_equal('/', p.path)
+    assert_equal('/', p.source_path)
+    assert_equal('/', p.directory)
+    assert_equal('/', p.cn)
+    assert_equal('/', p.meta_info['title'])
+
+    p = Webgen::Path.new('/test.rb', '/other.rb')
+    p = p.mount_at('/source/')
+    assert_equal('/source/test.rb', p.path)
+    assert_equal('/other.rb', p.source_path)
+    assert_equal('/source/', p.directory)
+    assert_equal('test.rb', p.cn)
+    assert_equal('Test', p.meta_info['title'])
+  end
+
+  def test_dup
+    p = Webgen::Path.new('test.de.page')
+    dupped = p.dup
+    dupped.meta_info['title'] = 'changed'
+    assert_equal('Test', p.meta_info['title'])
+  end
+
+  def test_io
+    p = Webgen::Path.new('test.de.page')
+    assert_raise(RuntimeError) { p.io }
+    p = Webgen::Path.new('test.de.page') { StringIO.new('hallo') }
+    assert_equal('hallo', p.io.data)
+    assert_equal('hallo', p.io.stream {|f| f.read })
+  end
+
+  def test_lcn
+    p = Webgen::Path.new('test.de.page')
+    assert_equal('test.page', p.cn)
+    assert_equal('test.de.page', p.lcn)
+    p = Webgen::Path.new('test.page')
+    assert_equal('test.page', p.cn)
+    assert_equal('test.page', p.lcn)
+  end
+
+  def test_equality
+    p = Webgen::Path.new('test.de.page')
+    assert_equal('test.de.page', p)
+    assert_equal(Webgen::Path.new('test.de.page'), p)
+    assert_not_equal(5, p)
+  end
+
+  def test_hashing
+    path = Webgen::Path.new('test.de.page')
+    h = { 'test.de.page' => :value }
+    assert_equal(:value, h['test.de.page'])
+    assert_equal(:value, h[path])
+    assert(path <=> 'test.de.page')
+    h = { p => :newvalue}
+    assert_nil(h['test.de.page'])
+  end
+
+  def test_matching
+    path = '/dir/to/file.de.page'
+    assert(Webgen::Path.match(path, '**/*'))
+    assert(Webgen::Path.match(path, '**/file.de.PAGE'))
+    assert(Webgen::Path.match(path, '/dir/*/file.*.page'))
+    assert(!Webgen::Path.match(path, '**/*.test'))
+
+    path = '/dir/'
+    assert(Webgen::Path.match(path, '/dir/'))
+    assert(Webgen::Path.match(path, '/dir'))
+
+    path = '/dir'
+    assert(Webgen::Path.match(path, '/dir/'))
+    assert(Webgen::Path.match(path, '/dir'))
+
+    path = '/'
+    assert(Webgen::Path.match(path, '/'))
+    assert(!Webgen::Path.match(path, ''))
+
+    path = ''
+    assert(!Webgen::Path.match(path, '/'))
+  end
+
+  def test_introspection
+    p = Webgen::Path.new('test.de.page')
+    assert_equal('test.de.page', p.to_s)
+    assert(p.inspect.include?('test.de.page'))
+  end
+
+  def test_changed?
+    p = Webgen::Path.new('test.de.page')
+    assert(p.changed?)
+  end
+
+end

data/test/test_source_filesystem.rb

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/source'
+require 'tmpdir'
+require 'fileutils'
+require 'rbconfig'
+
+class TestSourceFileSystemPath < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_io
+    path = Webgen::Source::FileSystem::Path.new('/test.rb', __FILE__)
+    assert(path.io.data =~ /TestSourceFileSystemPath/)
+  end
+
+  def test_changed?
+    path = Webgen::Source::FileSystem::Path.new('/test.rb', __FILE__)
+    assert(!path.changed?)
+    @website.cache.instance_eval { @old_data[[:fs_path, __FILE__]] = File.mtime(__FILE__) - 1 }
+    assert(path.changed?)
+    @website.cache.instance_eval { @old_data[[:fs_path, __FILE__]] = File.mtime(__FILE__) + 1 }
+    assert(!path.changed?)
+  end
+
+end
+
+class TestSourceFileSystem < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def setup
+    super
+    @website = Webgen::Website.new(File.join(File.dirname(__FILE__), '..'), nil)
+    @website.init
+    Thread.current[:webgen_website] = @website
+  end
+
+  def test_initialize
+    source = Webgen::Source::FileSystem.new('test', '**/*.page')
+    assert_equal('**/*.page', source.glob)
+    assert_equal(File.join(File.dirname(__FILE__), '..', 'test'), source.root)
+
+    source = Webgen::Source::FileSystem.new('/tmp/hallo')
+    assert_equal('**/*', source.glob)
+    assert_equal('/tmp/hallo', source.root)
+
+    source = Webgen::Source::FileSystem.new('c:/tmp/hallo')
+    assert_equal('c:/tmp/hallo', source.root)
+
+    source = Webgen::Source::FileSystem.new('../hallo')
+    assert_equal(File.join(@website.directory, '../hallo'), source.root)
+  end
+
+  def test_paths
+    source = Webgen::Source::FileSystem.new(File.join(File.dirname(__FILE__), '..', 'lib', 'webgen'), '/source/../**/*')
+    assert(source.paths.length > 1)
+    assert(source.paths.include?(Webgen::Path.new('/source/')))
+    assert(source.paths.include?(Webgen::Path.new('/source/filesystem.rb')))
+  end
+
+  def test_handling_of_invalid_link
+    return if Config::CONFIG['arch'].include?('mswin32')
+    dir = File.join(Dir.tmpdir, 'webgen-link-test')
+    FileUtils.mkdir_p(dir)
+    FileUtils.touch(File.join(dir, 'test'))
+    File.symlink('non-existing-file', File.join(dir, 'invalid-link'))
+    source = Webgen::Source::FileSystem.new(dir, '/t*')
+    assert(source.paths.length == 1)
+  ensure
+    FileUtils.rm_rf(dir) if dir
+  end
+
+end