webgen 1.0.0.beta1 → 1.0.0.beta2

data/lib/webgen/tag/tikz.rb

@@ -16,7 +16,7 @@ module Webgen
 
         add_tikz_options!(path, context)
 
-        node = context.website.ext.path_handler.create_secondary_nodes(path, body, 'copy', context.ref_node.alcn).first
+        node = context.website.ext.path_handler.create_secondary_nodes(path, body, context.ref_node.alcn).first
 
         attrs = {'alt' => ''}.merge(context[:config]['tag.tikz.img_attr']).collect do |name, value|
           "#{name.to_s}=\"#{value}\""
@@ -31,6 +31,7 @@ module Webgen
           path.meta_info[opt] = context[:config][opt]
         end
         path.meta_info['pipeline'] = 'tikz'
+        path.meta_info['handler'] = 'copy'
       end
       private_class_method :add_tikz_options!
 

data/lib/webgen/test_helper.rb

@@ -22,25 +22,16 @@ module Webgen
 
     # A special subclass of Webgen::Node that is used in testing when a "renderable" node is needed,
     # ie. one that has the necessary info set to be processed via Webgen::PathHandler::PageUtils.
-    class RenderNode < Webgen::Node
-
-      include Webgen::PathHandler::PageUtils
+    class RenderNode < Webgen::PathHandler::PageUtils::Node
 
       def initialize(page_data, parent, cn, dest_path, meta_info = {})
         super(parent, cn, dest_path, meta_info)
         page = Webgen::Page.from_data(page_data)
         self.node_info[:blocks] = page.blocks
+        self.node_info[:path_handler] = self
         self.meta_info.update(page.meta_info)
       end
 
-      def blocks
-        super(self)
-      end
-
-      def render_block(name, context)
-        super(self, name, context)
-      end
-
       def template_chain
         [self]
       end

data/lib/webgen/version.rb

@@ -3,6 +3,6 @@
 module Webgen
 
   # The version of webgen.
-  VERSION = '1.0.0.beta1'
+  VERSION = '1.0.0.beta2'
 
 end

data/test/webgen/content_processor/test_erb.rb

@@ -14,6 +14,10 @@ class TestErb < MiniTest::Unit::TestCase
     @context.content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% context.website %>"
     assert_equal("hallo6\n/test\n/test\n/test", cp.call(@context).content)
 
+    @website.config['content_processor.erb.trim_mode'] = '%'
+    @context.content = "% 3.times do\na\n% end"
+    assert_equal("a\na\na\n", cp.call(@context).content)
+
     @context.content = "\n<%= 5* %>"
     assert_error_on_line(SyntaxError, 2) { cp.call(@context) }
   end

data/test/webgen/content_processor/{test_rdoc.rb → test_r_doc.rb}

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'webgen/test_helper'
-require 'webgen/content_processor/rdoc'
+require 'webgen/content_processor/r_doc'
 
 class TestRDoc < MiniTest::Unit::TestCase
 

data/test/webgen/content_processor/{test_redcloth.rb → test_red_cloth.rb}

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'webgen/test_helper'
-require 'webgen/content_processor/redcloth'
+require 'webgen/content_processor/red_cloth'
 
 class TestRedCloth < MiniTest::Unit::TestCase
 

data/test/webgen/content_processor/test_sass.rb

@@ -22,8 +22,8 @@ class TestSass < MiniTest::Unit::TestCase
     assert_error_on_line(Webgen::RenderError, 2) { cp.call(@context) }
 
     # test @import-ing of sass files
-    content = "#main\n  background-image: relocatable('../dir2/file.test')"
-    result = "#main {\n  background-image: url(\"../../dir2/file.test\"); }\n"
+    content = "#main\n  background-image: url(relocatable('../dir2/file.test') + \"#iefix\")"
+    result = "#main {\n  background-image: url(\"../../dir2/file.test#iefix\"); }\n"
     root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
     dir = Webgen::Node.new(root, 'dir/', '/dir/')
     partial = Webgen::Node.new(dir, '_partial.sass', '/dir/_partial.sass')

data/test/webgen/content_processor/test_tikz.rb

@@ -9,6 +9,12 @@ class TestContentProcessorTikz < MiniTest::Unit::TestCase
 
   def test_static_call
     setup_context
+    @website.ext.content_processor = Webgen::ContentProcessor.new
+    @website.ext.content_processor.register('Blocks')
+    @website.ext.content_processor.register('Erb')
+    template_data = File.read(File.join(Webgen::Utils.data_dir, 'passive_sources', 'templates', 'tikz.template'))
+    node = RenderNode.new(template_data, @website.tree.dummy_root, '/template', '/template')
+
     @context.node.expect(:[], nil, ['ignored'])
 
     call('\tikz \draw (0,0) -- (0,1);', 'test.png', [], '', '72 72', false)
@@ -24,9 +30,10 @@ class TestContentProcessorTikz < MiniTest::Unit::TestCase
     @context.content = content
     @context.dest_node.expect(:dest_path, path)
     @context.website.config.update('content_processor.tikz.resolution' => res,
-                                  'content_processor.tikz.transparent' => trans,
-                                  'content_processor.tikz.libraries' => libs,
-                                  'content_processor.tikz.opts' => opts)
+                                   'content_processor.tikz.transparent' => trans,
+                                   'content_processor.tikz.libraries' => libs,
+                                   'content_processor.tikz.opts' => opts,
+                                   'content_processor.tikz.template' => '/template')
     Webgen::ContentProcessor::Tikz.call(@context)
   end
 

data/test/webgen/item_tracker/test_file.rb

@@ -19,13 +19,13 @@ class TestItemTrackerFile < MiniTest::Unit::TestCase
     assert_equal(File.mtime(__FILE__), @obj.item_data(__FILE__))
   end
 
-  def test_changed?
-    refute(@obj.changed?(__FILE__, Time.now))
-    assert(@obj.changed?(__FILE__, Time.parse("1980-01-01")))
+  def test_item_changed?
+    refute(@obj.item_changed?(__FILE__, Time.now))
+    assert(@obj.item_changed?(__FILE__, Time.parse("1980-01-01")))
   end
 
-  def test_node_referenced?
-    refute(@obj.node_referenced?('anything', 'nothing', '/alcn'))
+  def test_referenced_nodes
+    assert_equal([], @obj.referenced_nodes('anything', 'nothing'))
   end
 
 end

data/test/webgen/item_tracker/test_missing_node.rb

@@ -35,36 +35,35 @@ class TestItemTrackerMissingNode < MiniTest::Unit::TestCase
     assert_same(false, @obj.item_data('id', 'lang'))
   end
 
-  def test_changed?
+  def test_item_changed?
     @website.tree.answer = nil
 
     # run where missing node item was added
-    assert(@obj.changed?(['alcn', 'lang'], true))
+    assert(@obj.item_changed?(['alcn', 'lang'], true))
 
     @website.blackboard.dispatch_msg(:after_all_nodes_written)
 
     # run where at least one new node was created
     @website.blackboard.dispatch_msg(:after_node_created)
-    assert(@obj.changed?(['alcn', 'lang'], true))
+    assert(@obj.item_changed?(['alcn', 'lang'], true))
 
     @website.blackboard.dispatch_msg(:after_all_nodes_written)
     @website.blackboard.dispatch_msg(:after_all_nodes_written)
 
     # run where no new nodes were created and therefore "changing" stops
-    refute(@obj.changed?(['alcn', 'lang'], true))
+    refute(@obj.item_changed?(['alcn', 'lang'], true))
 
     @website.blackboard.dispatch_msg(:after_all_nodes_written)
     @website.blackboard.dispatch_msg(:website_generated)
 
     # on next invocation of website generation
     @website.tree.answer = :a42
-    assert(@obj.changed?(['alcn', 'lang'], true))
-    refute(@obj.changed?(['alcn', 'lang'], false))
+    assert(@obj.item_changed?(['alcn', 'lang'], true))
+    refute(@obj.item_changed?(['alcn', 'lang'], false))
   end
 
-  def test_node_referenced?
-    assert(@obj.node_referenced?(['alcn', 'lang'], true, 'alcn'))
-    refute(@obj.node_referenced?(['other', 'lang'], true, 'alcn'))
+  def test_referenced_nodes
+    assert_equal(['alcn'], @obj.referenced_nodes(['alcn', 'lang'], true))
   end
 
 end

data/test/webgen/item_tracker/test_node_content.rb

@@ -18,7 +18,7 @@ class TestNodeContent < MiniTest::Unit::TestCase
     assert_nil(@obj.item_data('alcn'))
   end
 
-  def test_changed?
+  def test_item_changed?
     item_tracker = MiniTest::Mock.new
     item_tracker.expect(:node_changed?, true, [:node])
     ext = MiniTest::Mock.new
@@ -26,17 +26,16 @@ class TestNodeContent < MiniTest::Unit::TestCase
     @website.expect(:ext, ext)
     @website.expect(:tree, {'alcn' => :node})
 
-    assert(@obj.changed?('unknown', 'old'))
-    assert(@obj.changed?('alcn', 'other'))
+    assert(@obj.item_changed?('unknown', 'old'))
+    assert(@obj.item_changed?('alcn', 'other'))
 
     @website.verify
     item_tracker.verify
     ext.verify
   end
 
-  def test_node_referenced?
-    assert(@obj.node_referenced?('alcn', nil, 'alcn'))
-    refute(@obj.node_referenced?('other', nil, 'alcn'))
+  def test_referenced_nodes
+    assert_equal(['alcn'], @obj.referenced_nodes('alcn', nil))
   end
 
 end

data/test/webgen/item_tracker/test_node_meta_info.rb

@@ -27,18 +27,17 @@ class TestNodeMetaInfo < MiniTest::Unit::TestCase
     @node.verify
   end
 
-  def test_changed?
+  def test_item_changed?
     @node.expect(:nil?, false)
-    assert(@obj.changed?(['unknown', nil], 'old'))
-    assert(@obj.changed?(['alcn', nil], {"key" => 'value', 'other' => 'new'}))
-    assert(@obj.changed?(['alcn', 'key'], 'new'))
+    assert(@obj.item_changed?(['unknown', nil], 'old'))
+    assert(@obj.item_changed?(['alcn', nil], {"key" => 'value', 'other' => 'new'}))
+    assert(@obj.item_changed?(['alcn', 'key'], 'new'))
     @website.verify
     @node.verify
   end
 
-  def test_node_referenced?
-    assert(@obj.node_referenced?(['alcn', nil], 'mi', 'alcn'))
-    refute(@obj.node_referenced?(['other', nil], 'mi', 'alcn'))
+  def test_referenced_nodes
+    assert_equal(['alcn'], @obj.referenced_nodes(['alcn', nil], 'mi'))
   end
 
 end

data/test/webgen/item_tracker/test_nodes.rb

@@ -36,26 +36,24 @@ class TestItemTrackerNodes < MiniTest::Unit::TestCase
                  @obj.item_data(*@args2))
   end
 
-  def test_changed?
+  def test_item_changed?
     setup_default_nodes(@website.tree)
     @website.ext.item_tracker = MiniTest::Mock.new
     @website.ext.item_tracker.expect(:item_changed?, false, [:node_meta_info, nil])
 
     [@args1, @args2].each do |args|
       old_data = @obj.item_data(*args)
-      assert(@obj.changed?(args, []))
-      refute(@obj.changed?(args, old_data))
+      assert(@obj.item_changed?(args, []))
+      refute(@obj.item_changed?(args, old_data))
     end
   end
 
-  def test_node_referenced?
+  def test_referenced_nodes
     setup_default_nodes(@website.tree)
 
-    assert(@obj.node_referenced?(@args1, @obj.item_data(*@args1), '/file.en.html'))
-    refute(@obj.node_referenced?(@args1, @obj.item_data(*@args1), '/dir/file.html'))
-
-    assert(@obj.node_referenced?(@args2, @obj.item_data(*@args2), '/file.en.html'))
-    refute(@obj.node_referenced?(@args2, @obj.item_data(*@args2), '/other.en.html'))
+    assert(["/file.en.html", "/file.de.html", "/other.html", "/other.en.html", "/german.de.html",
+            "/dir/", "/dir2/"].map {|f| @website.tree[f]},
+           @obj.referenced_nodes(@args1, @obj.item_data(*@args1)))
   end
 
 end

data/test/webgen/path_handler/test_base.rb

@@ -22,20 +22,19 @@ class TestPathHandlerBase < MiniTest::Unit::TestCase
     @obj = TestPathHandler.new(@website)
   end
 
-  def test_content
-    assert_nil(@obj.content(nil))
-  end
-
   def test_create_node
     count = 0
     assert_nil(@obj.create_node(Webgen::Path.new('/test.html', 'draft' => true)))
 
     path = Webgen::Path.new('/path.html', 'dest_path' => '<parent><basename>(.<lang>)<ext>',
                             'modified_at' => 'unknown', 'parent_alcn' => '')
-    node = @obj.create_node(path) {|n| count += 1; assert_kind_of(Webgen::Node, n)}
+    node = @obj.create_node(path) {|n| count += 1; assert_kind_of(Webgen::PathHandler::Base::Node, n)}
     assert_equal(path, node.node_info[:path])
     assert_kind_of(Time, node.meta_info['modified_at'])
     assert_equal(1, count)
+    assert_nil(node.content)
+    def (@obj).content(node); node; end
+    assert_equal(node, node.content)
 
     second_node = @obj.create_node(path) {|n| count += 1}
     assert_equal(1, count)

data/test/webgen/path_handler/test_page.rb

@@ -18,7 +18,7 @@ class TestPathHandlerPage < MiniTest::Unit::TestCase
     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(['content'], node.blocks)
     assert_equal('/default.en.html', node.alcn)
   end
 

data/test/webgen/path_handler/test_page_utils.rb

@@ -25,34 +25,62 @@ class TestPageUtils < MiniTest::Unit::TestCase
     assert_equal('value', path.meta_info['key'])
   end
 
+  def test_template_chain
+    setup_website('path_handler.default_template' => 'default.template')
+    @website.expect(:cache, Webgen::Cache.new)
+    @root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
+
+    default_template = MyHandler::Node.new(@root, 'default.template', '/default.template')
+    default_de_template = MyHandler::Node.new(@root, 'default.template', '/default.de.template', {'lang' => 'de'})
+    other_template = MyHandler::Node.new(@root, 'other.template', '/other.template')
+    stopped_template = MyHandler::Node.new(@root, 'stopped.html', '/stopped.page', { 'template' => nil})
+    invalid_template = MyHandler::Node.new(@root, 'invalid.template', '/invalid.template', {'template' => 'invalidity'})
+    chained_template = MyHandler::Node.new(@root, 'chained.template', '/chained.template', {'template' => 'other.template'})
+    german_file = MyHandler::Node.new(@root, 'german.page', '/german.html', {'lang' => 'de', 'template' => 'other.template'})
+    dir = Webgen::Node.new(@root, 'dir/', '/dir/')
+    dir_default_template = MyHandler::Node.new(dir, 'default.template', '/dir/default.template')
+    dir_dir = Webgen::Node.new(dir, 'dir/', '/dir/dir/')
+    dir_dir_file = MyHandler::Node.new(dir_dir, 'file.page', '/dir/dir/file.html', {'lang' => 'en'})
+
+    assert_equal([], default_template.template_chain)
+    assert_equal([], stopped_template.template_chain)
+    assert_equal([default_template], other_template.template_chain)
+    assert_equal([default_template], invalid_template.template_chain)
+    assert_equal([default_template, other_template], chained_template.template_chain)
+    assert_equal([default_de_template, other_template], german_file.template_chain)
+    assert_equal([default_template], dir_default_template.template_chain)
+    assert_equal([default_template, dir_default_template], dir_dir_file.template_chain)
+
+    @website.cache.reset_volatile_cache
+    @root.tree.delete_node(default_template)
+    assert_equal([], other_template.template_chain)
+  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])
+    node = MyHandler::Node.new(@website.tree.dummy_root, '/', '/')
+    node.node_info[:blocks] = {'content' => 'mycontent'}
 
     # invalid block name
-    assert_raises(Webgen::RenderError) { @handler.render_block(node, 'unknown', @context) }
+    assert_raises(Webgen::RenderError) { node.render_block('unknown', @context) }
 
     # nothing to render because pipeline is empty
-    @handler.render_block(node, 'content', @context)
+    node.render_block('content', @context)
     assert_equal('mycontent', @context.content)
 
     # invalid content processor
-    assert_raises(Webgen::Error) { @handler.render_block(node, 'content', @context, ['test']) }
+    assert_raises(Webgen::Error) { node.render_block('content', @context, ['test']) }
 
     node.meta_info['blocks'] = {'content' => {'pipeline' => ['test']}}
-    assert_raises(Webgen::Error) { @handler.render_block(node, 'content', @context) }
+    assert_raises(Webgen::Error) { node.render_block('content', @context) }
 
     # with content processor
     @website.ext.content_processor.register('test') {|ctx| ctx.content = 'test' + ctx.content; ctx}
-    @handler.render_block(node, 'content', @context)
+    node.render_block('content', @context)
     assert_equal('testmycontent', @context.content)
 
-    @handler.render_block(node, 'content', @context, ['test', 'test'])
+    node.render_block('content', @context, ['test', 'test'])
     assert_equal('testtestmycontent', @context.content)
   end
 

data/test/webgen/path_handler/test_template.rb

@@ -9,56 +9,16 @@ 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)
-
+  def test_create_nodes
+    setup_website
+    root = Webgen::Node.new(@website.tree.dummy_root, '/', '/')
     @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))
+    assert_equal(['content'], node.blocks)
+    assert(node['no_output'])
   end
 
 end