webgen 0.5.17 → 1.0.0.beta1

data/test/webgen/tag/test_meta_info.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/tag/meta_info'
+require 'time'
+
+class TestTagMetaInfo < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def test_call
+    setup_context
+    node = Webgen::Node.new(@website.tree.dummy_root, 'test', 'test', 'lang' => 'en', 'key' => 'value <br />')
+    @context[:chain] = [node]
+
+    @context[:config] = {'tag.meta_info.escape_html' => true}
+    assert_equal("en", Webgen::Tag::MetaInfo.call('lang', '', @context))
+    assert_equal("value &lt;br /&gt;", Webgen::Tag::MetaInfo.call('key', '', @context))
+    assert_equal("", Webgen::Tag::MetaInfo.call('invalid', '', @context))
+
+    @context[:config] = {'tag.meta_info.escape_html' => false}
+    assert_equal("value <br />", Webgen::Tag::MetaInfo.call('key', '', @context))
+  end
+
+end

data/test/webgen/tag/test_relocatable.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/tag/relocatable'
+
+class TestTagRelocatable < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def test_call
+    setup_context
+    @website.logger.verbose = true
+    setup_default_nodes(@website.tree)
+    @context[:chain] = [@website.tree['/file.en.html']]
+
+    # basic node resolving
+    assert_tag_result('dir/subfile.html', 'dir/subfile.html')
+    assert_tag_result('dir/subfile.html', 'dir/subfile.html', true)
+    assert_tag_result('', 'german.html')
+    assert_tag_result('', 'german.html', true)
+    assert_tag_result('', 'german.html#other')
+    assert_tag_result('', 'german.html#other', true)
+    assert_tag_result('german.other.html', 'german.de.html')
+    assert_tag_result('german.other.html', 'german.de.html', true)
+
+    # non-existing fragments but existing file
+    assert_tag_result('', 'file.html#hallo')
+    assert_tag_result('file.en.html#hallo', 'file.html#hallo', true)
+    assert_log_match(/Ignoring unknown fragment part/)
+
+    # absolute paths
+    assert_tag_result('http://test.com', 'http://test.com')
+
+    # directory paths
+    assert_tag_result('dir/', 'dir')
+    assert_tag_result('dir2/index.en.html', 'dir2')
+
+    # invalid paths
+    @context[:config] = {'tag.relocatable.path' => ':/asdf=-)'}
+    Webgen::Tag::Relocatable.call('relocatable', '', @context)
+    assert_log_match(/Could not parse path/)
+  end
+
+  def assert_tag_result(result, path, ignore_unknown_fragment = false)
+    @context[:config] = {'tag.relocatable.path' => path,
+      'tag.relocatable.ignore_unknown_fragment' => ignore_unknown_fragment}
+    assert_equal(result, Webgen::Tag::Relocatable.call('relocatable', '', @context))
+  end
+
+end

data/test/webgen/tag/test_tikz.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/tag/tikz'
+
+class TestTagTikz < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def test_call
+    setup_context
+    @website.ext.path_handler = MiniTest::Mock.new
+
+    root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'file.page', '/file.html')
+    tikz_node = Webgen::Node.new(root, 'test.png', '/test.png')
+    @context[:chain] = [node]
+
+    body = '\tikz \draw (0,0) -- (0,1);'
+    @website.ext.path_handler.expect(:create_secondary_nodes, [tikz_node],
+                                    [Webgen::Path.new('/test.png'), body, 'copy', '/file.page'])
+    assert_tag_result('<img src="test.png" alt="" />',
+                      body, 'test.png', [], '', '72 72', false, {})
+    @website.ext.path_handler.verify
+
+    @website.ext.path_handler.expect(:create_secondary_nodes, [tikz_node],
+                                    [Webgen::Path.new('/images/test.png'), body, 'copy', '/file.page'])
+    assert_tag_result('<img src="test.png" alt="title" />',
+                      body, 'images/test.png', ['arrows'], '->', '72 72', true, {'alt' => 'title'})
+    @website.ext.path_handler.verify
+
+  end
+
+  def assert_tag_result(result, body, path, libs, opts, res, trans, imgattr)
+    @context[:config] = {'tag.tikz.path' => path, 'content_processor.tikz.libraries' => libs,
+      'content_processor.tikz.opts' => opts, 'content_processor.tikz.resolution' => res,
+      'content_processor.tikz.transparent' => trans, 'tag.tikz.img_attr' => imgattr}
+    assert_equal(result, Webgen::Tag::Tikz.call('tikz', body, @context))
+  end
+
+end

data/test/webgen/task/test_create_website.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/test_helper'
+require 'webgen/task/create_website'
+require 'fileutils'
+require 'ostruct'
+
+class TestTaskCreateWebsite < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website
+    @website.ext.task = @task = Webgen::Task.new(@website)
+    @task.register('CreateWebsite', :data => {:templates => {}})
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@website.directory)
+  end
+
+  def test_static_call
+    @task.execute(:create_website)
+    assert(File.directory?(@website.directory))
+    assert(File.directory?(File.join(@website.directory, 'src')))
+    assert(File.file?(File.join(@website.directory, 'webgen.config')))
+
+    assert_raises(Webgen::Task::CreateWebsite::Error) { @task.execute(:create_website) }
+  end
+
+  def test_static_call_with_template
+    Dir.mktmpdir do |tmpdir|
+      Dir.mkdir(File.join(tmpdir, 'tmp'))
+      File.open(File.join(tmpdir, 'tmp', 'test.erb.txt'), 'w+') {|f| f.write("<%= '#{tmpdir}' %>")}
+      @task.data(:create_website)[:templates]['my_template'] = tmpdir
+
+      @task.execute(:create_website, 'my_template')
+      assert(File.directory?(@website.directory))
+      assert(File.directory?(File.join(@website.directory, 'tmp')))
+      assert_equal(tmpdir, File.read(File.join(@website.directory, 'tmp', 'test.txt')))
+      refute(File.directory?(File.join(@website.directory, 'src')))
+      refute(File.file?(File.join(@website.directory, 'webgen.config')))
+    end
+  end
+
+end

data/test/webgen/test_blackboard.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/blackboard'
+
+class TestBlackboard < MiniTest::Unit::TestCase
+
+  def setup
+    @blackboard = Webgen::Blackboard.new
+  end
+
+  def test_add_listener
+    assert_raises(ArgumentError) { @blackboard.add_listener(:test) }
+    @blackboard.add_listener([:test, :other]) { throw :called }
+    assert_throws(:called) { @blackboard.dispatch_msg(:test) }
+    assert_throws(:called) { @blackboard.dispatch_msg(:other) }
+  end
+
+  def test_remove_listener
+    @blackboard.add_listener(:test, 'id') { throw :called }
+    assert_throws(:called) { @blackboard.dispatch_msg(:test) }
+    @blackboard.remove_listener(:test, 'id')
+    @blackboard.dispatch_msg(:test)
+  end
+
+  def test_dispatch_msg
+    @blackboard.add_listener(:test) { throw :called }
+    assert_throws(:called) { @blackboard.dispatch_msg(:test) }
+  end
+
+end

data/test/webgen/test_bundle_loader.rb

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+
+require 'fileutils'
+require 'webgen/test_helper'
+require 'webgen/bundle_loader'
+
+class TestBundleLoader < MiniTest::Unit::TestCase
+
+  include Webgen::TestHelper
+
+  def setup
+    setup_website
+
+    @extdir = File.join(@website.directory, 'ext')
+    FileUtils.mkdir_p(File.join(@extdir, 'my_ext'))
+    FileUtils.mkdir_p(File.join(@extdir, 'webgen'))
+    @webgen_file = File.join(@extdir, 'webgen', 'init.rb')
+    FileUtils.touch(@webgen_file)
+    @ext_file = File.join(@extdir, 'my_ext', 'init.rb')
+    FileUtils.touch(@ext_file)
+    @ext_info_file = File.join(@extdir, 'my_ext', 'info.yaml')
+    FileUtils.touch(@ext_info_file)
+
+    @loader = Webgen::BundleLoader.new(@website, @extdir)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@website.directory)
+  end
+
+  def test_load
+    @loader.load('webgen')
+    @loader.load('my_ext')
+    @loader.load('my_ext')
+    assert_equal([File.expand_path(@webgen_file), File.expand_path(@ext_file)], @loader.instance_variable_get(:@loaded))
+    assert_equal({'webgen' => nil, 'my_ext' => @ext_info_file}, @website.ext.bundles)
+  end
+
+  def test_dsl
+    File.open(File.join(@extdir, 'init.rb'), 'w+') do |f|
+      f.puts("load('my_ext'); require_relative('webgen/init.rb')")
+    end
+    File.open(@ext_file, 'w+') do |f|
+      f.puts("mount_passive('data', '/test', '*.hallo')")
+    end
+    @website.ext.source = OpenStruct.new
+    @website.ext.source.passive_sources = [['/', :file, 'other']]
+
+    @loader.load('init.rb')
+    assert($LOADED_FEATURES.include?(@webgen_file))
+    assert_equal([['/test', :file_system, File.expand_path(File.dirname(@ext_file) + '/data'), '*.hallo'],
+                  ['/', :file, 'other']], @website.ext.source.passive_sources)
+  end
+
+end

data/test/{test_cache.rb → webgen/test_cache.rb}

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-require 'rubygems'
-require 'test/unit'
+
+require 'minitest/autorun'
 require 'webgen/cache'
 
-class TestCache < Test::Unit::TestCase
+class TestCache < MiniTest::Unit::TestCase
 
   def setup
     @cache = Webgen::Cache.new
@@ -40,20 +40,8 @@ class TestCache < Test::Unit::TestCase
     assert_equal(nil, @cache.volatile[:key])
 
     @cache.volatile[:key] = :value
-    obj = @cache.instance('Hash')
     @cache.reset_volatile_cache
     assert_equal(nil, @cache.volatile[:key])
-    assert_equal(obj, @cache.instance('Hash'))
-  end
-
-  def test_instance
-    obj = @cache.instance('Hash')
-    assert_kind_of(Hash, obj)
-    assert_equal(obj, @cache.instance('Hash'))
-    @cache.instance('Array')
-    assert_equal(['Hash', 'Array'], @cache.permanent[:classes])
-    dump_and_restore
-    assert_not_nil(@cache.volatile[:classes]['Hash'])
   end
 
 end

data/test/webgen/test_cli.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'webgen/cli'
+
+class TestCLICommandParser < MiniTest::Unit::TestCase
+
+  class SampleCommand < CmdParse::Command
+    def initialize
+      super('sample', false)
+    end
+  end
+
+  def setup
+    @cli = Webgen::CLI::CommandParser.new
+  end
+
+  def test_initialize
+    assert_equal(Logger::INFO, @cli.log_level)
+    assert_equal(nil, @cli.directory)
+  end
+
+  def test_website
+    assert_equal(Dir.pwd, @cli.website.directory)
+    assert_equal(@cli, @cli.website.ext.cli)
+  end
+
+  def test_parse
+    @cli.website.ext.cli.add_command(SampleCommand.new)
+    out, err = capture_io do
+      begin
+        @cli.parse(['help'])
+        assert_equal(Dir.pwd, @cli.directory + '/')
+      rescue SystemExit
+      end
+    end
+    assert_match(/Global options:/, out)
+    assert_match(/bundle.*create.*install.*list.*generate.*help.*sample.*.*show.*config.*deps.*extensions.*version/m, out)
+  end
+
+end

data/test/webgen/test_configuration.rb

@@ -0,0 +1,131 @@
+# -*- encoding: utf-8 -*-
+
+require 'tmpdir'
+require 'stringio'
+
+require 'minitest/autorun'
+require 'webgen/configuration'
+
+class TestConfiguration < MiniTest::Unit::TestCase
+
+  def setup
+    @config = Webgen::Configuration.new
+    add_default_option
+  end
+
+  def add_default_option
+    @config.define_option('namespace.option', 'default', 'desc') {|v| raise "Error with option" unless v.kind_of?(String); v}
+  end
+
+  def test_defining_options
+    assert(@config.options['namespace.option'])
+    assert_equal('default', @config.options['namespace.option'].default)
+    assert_equal('desc', @config.options['namespace.option'].description)
+    assert_kind_of(Proc, @config.options['namespace.option'].validator)
+
+    assert_raises(ArgumentError) { add_default_option }
+  end
+
+  def test_has_option
+    assert(@config.option?('namespace.option'))
+    refute(@config.option?('unknown.option'))
+  end
+
+  def test_get_option_value
+    assert_equal('default', @config['namespace.option'])
+    assert_raises(Webgen::Configuration::Error) { @config['unknown'] }
+
+    @config.define_option('other', :sym, 'desc')
+    assert_equal(:sym, @config['other'])
+  end
+
+  def test_set_and_modify_option_value
+    @config['namespace.option'].tr!('de', 'en')
+    assert_equal('enfault', @config['namespace.option'])
+    assert_equal('default', @config.options['namespace.option'].default)
+    @config['namespace.option'] = 'other'
+    assert_equal('other', @config['namespace.option'])
+
+    assert_raises(Webgen::Configuration::Error) { @config['namespace.option'] = :other }
+    assert_raises(Webgen::Configuration::Error) { @config['unknown'] = 'other' }
+  end
+
+  def test_set_values
+    result = @config.set_values('namespace.option' => 'other')
+    assert_empty(result)
+    assert_equal('other', @config['namespace.option'])
+
+    result = @config.set_values('namespace' => {'option' => 'new', 'opt2' => :val}, 'other' => :val)
+    assert_equal(['namespace.opt2', 'other'], result)
+    assert_equal('new', @config['namespace.option'])
+
+    assert_raises(Webgen::Configuration::Error) { @config.set_values('namespace.option' => :test) }
+  end
+
+  def test_frozen_config
+    @config.freeze
+    assert_equal('default', @config['namespace.option'])
+    assert_raises(Webgen::Configuration::Error) { @config['namespace.option'] = 'other' }
+    assert_raises(RuntimeError) { @config.define_option('nonsense', 'val', 'desc') }
+  end
+
+  def test_load_from_file_exceptions
+    assert_raises(ArgumentError) { @config.load_from_file(5) }
+    assert_raises(Webgen::Configuration::Error) { @config.load_from_file(StringIO.new("[namespace.option, test]")) }
+    assert_raises(Webgen::Configuration::Error) { @config.load_from_file(StringIO.new("[asdfds")) }
+  end
+
+  def test_load_value_from_file
+    Dir.mktmpdir('webgen-configuration') do |dir|
+      file = File.join(dir, 'config.yaml')
+      File.open(file, 'w+') {|f| f.write("namespace.option: test")}
+
+      assert_empty(@config.load_from_file(file))
+      assert_equal('test', @config['namespace.option'])
+    end
+  end
+
+  def test_load_value_from_io
+    assert_empty(@config.load_from_file(StringIO.new("namespace.option: test")))
+    assert_equal('test', @config['namespace.option'])
+  end
+
+  def test_initialize_copy
+    @config.set_values({'namespace.option' => 'value'})
+    @config.freeze
+
+    cloned = @config.clone
+    assert(@config.frozen?)
+    assert_raises(Webgen::Configuration::Error) { cloned['namespace.option'] = 'other' }
+    assert_raises(RuntimeError) { cloned.define_option('nonsense', 'val', 'desc') }
+
+    dupped = @config.dup
+    refute(dupped.frozen?)
+
+    dupped.define_option('test', '', '')
+    assert(dupped.option?('test'))
+    refute(@config.option?('test'))
+
+    dupped.set_values({'namespace.option' => 'other'})
+    assert_equal('other', dupped['namespace.option'])
+    assert_equal('value', @config['namespace.option'])
+  end
+
+  def test_equality
+    other = Webgen::Configuration.new
+    other.define_option('namespace.option', 'default', 'desc') {|v| raise "Error with option" unless v.kind_of?(String); v}
+    assert_equal(@config, other)
+
+    other['namespace.option'] = 'val'
+    @config['namespace.option'] = 'val'
+    assert_equal(@config, other)
+
+    @config['namespace.option'] = 'val1'
+    refute_equal(@config, other)
+
+    other = Webgen::Configuration.new
+    other.define_option('namespace.option', 'default1', 'desc')
+    refute_equal(@config, other)
+  end
+
+end