webgen 0.5.17 → 1.0.0.beta1

data/test/webgen/path_handler/test_feed.rb

@@ -0,0 +1,85 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/feed'
+require 'webgen/content_processor'
+require 'webgen/node_finder'
+require 'webgen/path'
+require 'webgen/version'
+
+class TestPathHandlerFeed < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  FEED_CONTENT = <<EOF
+---
+site_url: http://example.com
+entries:
+  :alcn: "*.html"
+author: Thomas Leitner
+content_block_name: abstract
+--- name:rss_template
+hallo
+EOF
+
+  def setup
+    setup_website('website.lang' => 'en')
+    @website.ext.node_finder = Webgen::NodeFinder.new(@website)
+
+    @feed = Webgen::PathHandler::Feed.new(@website)
+
+    root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    @index_en = RenderNode.new("--- name:content\nMyContent\n--- name:abstract\nRealContent", root,
+                               'index.html', '/index.en.html', {'lang' => 'en', 'modified_at' => Time.now - 1, 'author' => 'test'})
+    @file_en = RenderNode.new("--- name:content\nCContent\n--- name:abstract\nAContent", root,
+                              'file.html', '/file.en.html', {'lang' => 'en', 'modified_at' => Time.now - 2})
+
+    template_data = File.read(File.join(Webgen::Utils.data_dir, 'passive_sources', 'templates', 'feed.template'))
+    RenderNode.new(template_data, root, 'feed.template', '/templates/feed.template')
+
+    @path = Webgen::Path.new('/test_feed', 'dest_path' => '<parent><basename><ext>') { StringIO.new(FEED_CONTENT) }
+    @path.meta_info.update(Webgen::Page.from_data(FEED_CONTENT).meta_info)
+    @path_blocks = Webgen::Page.from_data(FEED_CONTENT).blocks
+  end
+
+  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

data/test/webgen/path_handler/test_meta_info.rb

@@ -0,0 +1,98 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/meta_info'
+require 'webgen/path'
+
+class TestPathHandlerMetaInfo < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  class TestPathHandler
+    include Webgen::PathHandler::Base
+    public :create_node
+  end
+
+  CONTENT=<<EOF
+--- paths
+/default.*:
+  title: new title
+  before: valbef
+
+/*/:
+  title: test
+--- alcn
+/default.css:
+  after: valaft
+
+/other.page:
+  title: Not Other
+EOF
+
+  def setup
+    setup_website
+    @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    @mi = Webgen::PathHandler::MetaInfo.new(@website)
+    @ph = TestPathHandler.new(@website)
+  end
+
+  def setup_default_node
+    @path = Webgen::Path.new('/metainfo', 'dest_path' => '<parent><basename><ext>')
+    @mi.create_nodes(@path, Webgen::Page.from_data(CONTENT).blocks)
+  end
+
+  def test_create_node
+    setup_default_node
+    result = [['/default.*', {'title' => 'new title', 'before' => 'valbef'}],
+              ['/*/', {'title' => 'test'}]]
+    @mi.instance_variable_get(:@paths).each_with_index do |(pattern, mi), index|
+      assert_equal(result[index].first, pattern)
+      assert_equal(result[index].last, Marshal.load(mi))
+    end
+
+    result = [['/default.css', {'after' => 'valaft'}],
+              ['/other.page', {'title' => 'Not Other'}]]
+    @mi.instance_variable_get(:@alcns).each_with_index do |(pattern, mi), index|
+      assert_equal(result[index].first, pattern)
+      assert_equal(result[index].last, Marshal.load(mi))
+    end
+
+    path = Webgen::Path.new('/default.metainfo', 'dest_path' => '<parent><basename><ext>')
+    assert_raises(Webgen::NodeCreationError) do
+      @mi.create_nodes(path, Webgen::Page.from_data("--- alcn\nhallo: test\n\ntest]du").blocks)
+    end
+  end
+
+  def test_before_node_created
+    setup_default_node
+
+    path = Webgen::Path.new('/default.css')
+    @website.blackboard.dispatch_msg(:before_node_created, path)
+    assert('valbef', path.meta_info['before'])
+
+    path = Webgen::Path.new('/hallo/')
+    @website.blackboard.dispatch_msg(:before_node_created, path)
+    assert('test', path.meta_info['title'])
+  end
+
+  def test_update_existing_nodes
+    path = Webgen::Path.new('/default.css', 'dest_path' => '<parent><basename><ext>')
+    node = @ph.create_node(path)
+
+    setup_default_node
+
+    assert('valaft', node['after'])
+  end
+
+  def test_after_node_created
+    setup_default_node
+
+    path = Webgen::Path.new('/default.css', 'dest_path' => '<parent><basename><ext>')
+    node = @ph.create_node(path)
+
+    refute_equal('valaft', node['after'])
+    @website.blackboard.dispatch_msg(:after_node_created, node)
+    assert_equal('valaft', node['after'])
+  end
+
+end

data/test/webgen/path_handler/test_page.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/page'
+require 'webgen/path'
+
+class TestPathHandlerPage < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website('website.lang' => 'en')
+    @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    @page = Webgen::PathHandler::Page.new(@website)
+  end
+
+  def test_create_node
+    path = Webgen::Path.new('/default.page', 'dest_path' => '<parent><basename><ext>') { StringIO.new('test') }
+    node = @page.create_nodes(path, ['content'])
+    refute_nil(node)
+    assert_equal(['content'], @page.blocks(node))
+    assert_equal('/default.en.html', node.alcn)
+  end
+
+end

data/test/webgen/path_handler/test_page_utils.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/page_utils'
+require 'webgen/content_processor'
+require 'webgen/path'
+
+class TestPageUtils < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  class MyHandler
+    include Webgen::PathHandler::PageUtils
+  end
+
+  def setup
+    @handler = MyHandler.new
+  end
+
+  def test_parse_as_page!
+    path = Webgen::Path.new('/test.html') { StringIO.new("---\nkey: value\n---\ncontent") }
+    blocks = @handler.send(:parse_as_page!, path)
+    assert_kind_of(Hash, blocks)
+    assert_equal('content', blocks['content'])
+    assert_equal('value', path.meta_info['key'])
+  end
+
+  def test_render_block
+    setup_context
+    node = @context.node
+    node.expect(:blocks, {'content' => 'mycontent'})
+    @context.node.expect(:meta_info, {})
+    @website.ext.content_processor = Webgen::ContentProcessor.new
+    @website.ext.item_tracker = MiniTest::Mock.new
+    @website.ext.item_tracker.expect(:add, nil, [node, :node_content, node.alcn])
+
+    # invalid block name
+    assert_raises(Webgen::RenderError) { @handler.render_block(node, 'unknown', @context) }
+
+    # nothing to render because pipeline is empty
+    @handler.render_block(node, 'content', @context)
+    assert_equal('mycontent', @context.content)
+
+    # invalid content processor
+    assert_raises(Webgen::Error) { @handler.render_block(node, 'content', @context, ['test']) }
+
+    node.meta_info['blocks'] = {'content' => {'pipeline' => ['test']}}
+    assert_raises(Webgen::Error) { @handler.render_block(node, 'content', @context) }
+
+    # with content processor
+    @website.ext.content_processor.register('test') {|ctx| ctx.content = 'test' + ctx.content; ctx}
+    @handler.render_block(node, 'content', @context)
+    assert_equal('testmycontent', @context.content)
+
+    @handler.render_block(node, 'content', @context, ['test', 'test'])
+    assert_equal('testtestmycontent', @context.content)
+  end
+
+end

data/test/webgen/path_handler/test_sitemap.rb

@@ -0,0 +1,95 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/sitemap'
+require 'webgen/content_processor'
+require 'webgen/node_finder'
+require 'webgen/path'
+
+class TestPathHandlerSitemap < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  SITEMAP_CONTENT = <<EOF
+---
+site_url: http://example.com
+default_change_freq: daily
+default_priority: 0.5
+entries:
+  :alcn: /**/*.html
+EOF
+
+  SITEMAP_CONTENT_TEMPLATE = <<EOF
+---
+site_url: http://example.com
+default_change_freq: daily
+default_priority: 0.5
+entries:
+  :alcn: /**/*.html
+--- name:sitemap pipeline:erb
+Yeah <%= context.node['title'] %>
+EOF
+
+  def setup
+    setup_website('website.lang' => 'en')
+    @website.ext.node_finder = Webgen::NodeFinder.new(@website)
+
+    @sitemap = Webgen::PathHandler::Sitemap.new(@website)
+
+    setup_default_nodes(@website.tree)
+    @website.tree.node_access[:alcn].each_value {|n| n.meta_info['modified_at'] = Time.now}
+    @website.tree['/file.en.html'].meta_info['priority'] = 0.9
+    @website.tree['/file.en.html'].meta_info['change_freq'] = 'hourly'
+
+    template_data = File.read(File.join(Webgen::Utils.data_dir, 'passive_sources', 'templates', 'sitemap.template'))
+    RenderNode.new(template_data, @website.tree.root, 'sitemap.template', '/templates/sitemap.template')
+
+    @path = Webgen::Path.new('/test.sitemap', 'dest_path' => '<parent><basename><ext>') { StringIO.new(SITEMAP_CONTENT) }
+    @path.meta_info.update(Webgen::Page.from_data(SITEMAP_CONTENT).meta_info)
+  end
+
+  def test_create_node
+    node = @sitemap.create_nodes(@path, Webgen::Page.from_data(@path.data).blocks)
+
+    refute_nil(node)
+    assert_equal('/test.xml', node.dest_path)
+    assert_equal('/test.xml', node.alcn)
+
+    assert_raises(Webgen::NodeCreationError) do
+      path = Webgen::Path.new('/test_feed_2') { StringIO.new("---\nunknow: yes") }
+      @sitemap.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')
+
+    content = @sitemap.create_nodes(@path, Webgen::Page.from_data(@path.data).blocks).content
+    assert_match(/<changefreq>daily<\/changefreq>/, content)
+    assert_match(/<changefreq>hourly<\/changefreq>/, content)
+    assert_match(/<priority>0.5<\/priority>/, content)
+    assert_match(/<priority>0.9<\/priority>/, content)
+  end
+
+  def test_content_with_template
+    @website.ext.content_processor = Webgen::ContentProcessor.new
+    @website.ext.content_processor.register('Erb')
+    @website.ext.content_processor.register('Blocks')
+
+    path = Webgen::Path.new('/test.sitemap', 'dest_path' => '<parent><basename><ext>') { StringIO.new(SITEMAP_CONTENT_TEMPLATE) }
+    path.meta_info.update(Webgen::Page.from_data(SITEMAP_CONTENT_TEMPLATE).meta_info)
+    node = @sitemap.create_nodes(path, Webgen::Page.from_data(path.data).blocks)
+
+    assert_equal("Yeah Test\n", node.content)
+  end
+
+  def test_sitemap_entries
+    node = @sitemap.create_nodes(@path, Webgen::Page.from_data(@path.data).blocks)
+    assert_equal(%w[/file.en.html /file.de.html /other.html /other.en.html /german.de.html
+                    /dir/subfile.html /dir/dir/file.html /dir2/index.en.html
+                    /dir2/index.de.html].map {|n| @website.tree[n]}, node.sitemap_entries)
+  end
+
+end

data/test/webgen/path_handler/test_template.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/template'
+require 'webgen/path'
+require 'webgen/cache'
+
+class TestPathHandlerTemplate < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website('path_handler.template.default_template' => 'default.template')
+    @website.expect(:cache, Webgen::Cache.new)
+
+    @template = Webgen::PathHandler::Template.new(@website)
+    @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+  end
+
+  def test_create_nodes
+    path = Webgen::Path.new('/default.template', 'dest_path' => '<parent><basename><ext>') { StringIO.new('test') }
+    node = @template.create_nodes(path, ['content'])
+    refute_nil(node)
+    assert_equal(['content'], @template.blocks(node))
+  end
+
+  def test_template_chain
+    default_template = Webgen::Node.new(@root, 'default.template', '/default.template')
+    default_de_template = Webgen::Node.new(@root, 'default.template', '/default.de.template', {'lang' => 'de'})
+    other_template = Webgen::Node.new(@root, 'other.template', '/other.template')
+    stopped_template = Webgen::Node.new(@root, 'stopped.html', '/stopped.page', { 'template' => nil})
+    invalid_template = Webgen::Node.new(@root, 'invalid.template', '/invalid.template', {'template' => 'invalidity'})
+    chained_template = Webgen::Node.new(@root, 'chained.template', '/chained.template', {'template' => 'other.template'})
+    german_file = Webgen::Node.new(@root, 'german.page', '/german.html', {'lang' => 'de', 'template' => 'other.template'})
+    dir = Webgen::Node.new(@root, 'dir/', '/dir/')
+    dir_default_template = Webgen::Node.new(dir, 'default.template', '/dir/default.template')
+    dir_dir = Webgen::Node.new(dir, 'dir/', '/dir/dir/')
+    dir_dir_file = Webgen::Node.new(dir_dir, 'file.page', '/dir/dir/file.html', {'lang' => 'en'})
+
+    assert_equal([], @template.template_chain(default_template))
+    assert_equal([], @template.template_chain(stopped_template))
+    assert_equal([default_template], @template.template_chain(other_template))
+    assert_equal([default_template], @template.template_chain(invalid_template))
+    assert_equal([default_template, other_template], @template.template_chain(chained_template))
+    assert_equal([default_de_template, other_template], @template.template_chain(german_file))
+    assert_equal([default_template], @template.template_chain(dir_default_template))
+    assert_equal([default_template, dir_default_template], @template.template_chain(dir_dir_file))
+
+    @website.cache.reset_volatile_cache
+    @root.tree.delete_node(default_template)
+    assert_equal([], @template.template_chain(other_template))
+  end
+
+  def test_default_template
+    dir = Webgen::Node.new(@root, 'dir/', '/dir/')
+    template = Webgen::Node.new(@root, 'default.template', '/default.template')
+
+    assert_equal(template, @template.default_template(@root, nil))
+    assert_equal(template, @template.default_template(dir, nil))
+    @website.tree.delete_node(template)
+    assert_nil(@template.default_template(@root, nil))
+  end
+
+end

data/test/webgen/path_handler/test_virtual.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/path_handler/virtual'
+require 'webgen/path'
+
+class TestPathHandlerVirtual < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  class SimplePathHandler
+
+    def initialize(virtual)
+      @virtual = virtual
+    end
+
+    def create_secondary_nodes(path)
+      path.meta_info[:virtual] = true
+      path.meta_info['dest_path'] ||= '<parent><basename>(.<lang>)<ext>'
+      @virtual.create_nodes(path, {})
+    end
+
+  end
+
+  CONTENT=<<EOF
+\\--- !omap
+- path.de.html:
+
+- /dir/:
+    title: My Dir
+
+- /dir/file.html:
+
+- /directory/path.en.html:
+    dest_path: other.html
+    title: new title
+
+- api.html:
+    dest_path: http://www.example.com
+    title: Absolute
+
+- other.html:
+    dest_path: directory/path.en.html
+    title: Nothing
+
+- /dirnew/dirnew/dirnew/:
+    dest_path: /
+    title: root
+EOF
+
+
+  def setup
+    setup_website
+    @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    @virtual = Webgen::PathHandler::Virtual.new(@website)
+    @website.ext.path_handler = SimplePathHandler.new(@virtual)
+  end
+
+  def test_create_node
+    @time = Time.now
+    path = Webgen::Path.new('/virtual', 'dest_path' => '<parent><basename>(.<lang>)<ext>', 'modified_at' => @time)
+    nodes = @virtual.create_nodes(path, Webgen::Page.from_data(CONTENT).blocks)
+
+    nodes.each {|n| assert_equal(path, n.node_info[:path])}
+
+    node_de = @root.tree['/path.de.html']
+    node_en = @root.tree['/directory/path.en.html']
+    dir = @root.tree['/dir/']
+
+    refute_nil(node_de)
+    refute_nil(dir)
+    refute_nil(node_en)
+    refute_nil(@root.tree['/dirnew/dirnew/dirnew/'])
+
+    assert_equal('new title', node_en['title'])
+    assert_equal(@time.tv_usec, node_en['modified_at'].tv_usec)
+    assert(node_en['no_output'])
+    assert_equal('My Dir', dir['title'])
+    assert_equal('directory/other.html', node_de.route_to(node_en))
+    assert_equal('../path.de.html', dir.route_to(node_de))
+    assert_equal('../directory/other.html', dir.route_to(node_en))
+
+    assert_equal('http://www.example.com', @root.tree['/api.html'].dest_path)
+    assert_equal('http://www.example.com', @root.tree['/path.de.html'].route_to(@root.tree['/api.html']))
+  end
+
+end