webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/task/generate_website.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+require 'benchmark'
+require 'webgen/task'
+
+module Webgen
+  class Task
+
+    # Generates the website.
+    #
+    # This can be called the main task of webgen.
+    module GenerateWebsite
+
+      # Main webgen task: Generate the website.
+      #
+      # Returns +true+ if the website has been successfully generated.
+      def self.call(website)
+        successful = true
+        website.logger.info { "Generating website..." }
+        time = Benchmark.measure do
+          website.ext.path_handler.populate_tree
+          if website.tree.root && !website.tree.root['passive']
+            passes = website.ext.path_handler.write_tree
+            if passes == 0
+              website.logger.info { "Nothing has changed since the last invocation!" }
+            else
+              website.logger.vinfo do
+                "Needed #{passes} pass#{passes == 1 ? '' : 'es'} to generate the website"
+              end
+            end
+          else
+            successful = false
+            website.logger.info do
+              ['No active source paths found - maybe not a webgen website?',
+               'Change to a website directory and run the command again.']
+            end
+          end
+        end
+        website.logger.info { "... done in " << ('%2.2f' % time.real) << ' seconds' }
+        website.save_cache if successful
+        successful
+      end
+
+    end
+
+  end
+end

data/lib/webgen/test_helper.rb

@@ -0,0 +1,183 @@
+# -*- encoding: utf-8 -*-
+
+require 'minitest/autorun'
+require 'ostruct'
+require 'tmpdir'
+require 'stringio'
+require 'webgen/logger'
+
+require 'webgen/blackboard'
+require 'webgen/cache'
+require 'webgen/context'
+require 'webgen/page'
+require 'webgen/error'
+require 'webgen/tree'
+require 'webgen/node'
+require 'webgen/path_handler/page_utils'
+require 'webgen/utils'
+
+module Webgen
+
+  module TestHelper
+
+    # 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
+
+      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.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
+
+    end
+
+
+    # Fails if the given block does not raise error_class and the error is not on the line.
+    def assert_error_on_line(error_class, line)
+      begin
+        yield
+      rescue error_class => e
+        assert_equal(line, (e.respond_to?(:line) ? e.line : Webgen::Error.error_line(e)))
+      else
+        fail "No exception raised though #{error_class} expected"
+      end
+    end
+
+    # Fails if the log string is not empty.
+    #
+    # Uses the StringIO @logio if no other StringIO is given.
+    def assert_nothing_logged(io = @logio)
+      assert_equal('', io.string)
+    end
+
+    # Fails if the log string does not match the regular expression.
+    #
+    # Uses the StringIO @logio if no other StringIO is given and resets the log string after the
+    # check.
+    def assert_log_match(reg, io = @logio)
+      assert_match(reg, io.string)
+      @logio.string = ''
+    end
+
+    # Creates a basic mock website that is accessible via @website with the following methods:
+    #
+    # [@website.config]
+    #   The given config object or {} if none specified
+    #
+    # [@website.directory]
+    #   Set to a non-existent temporary directory
+    #
+    # [@website.tmpdir]
+    #   Set to @website.directory/tmp
+    #
+    # [@website.ext]
+    #   OpenStruct instance. The accessor +item_tracker+ is set to an object that responds to +add+.
+    #
+    # [@website.blackboard]
+    #   A Webgen::Blackboard instance
+    #
+    # [@website.logger]
+    #   Webgen::Logger instance with a StringIO as target. The StringIO target is also available
+    #   via @logio.
+    #
+    # [@website.tree]
+    #   Webgen::Tree instance
+    def setup_website(config = {})
+      @website = MiniTest::Mock.new
+      @website.expect(:config, config)
+      directory = Dir::Tmpname.create("test-webgen-website") {|path| raise Errno::EEXIST if File.directory?(path)}
+      @website.expect(:directory, directory)
+      def (@website).tmpdir(path=''); File.join(self.directory, 'tmp', path); end
+      @website.expect(:ext, OpenStruct.new)
+      @website.expect(:blackboard, Webgen::Blackboard.new)
+      @website.expect(:cache, Webgen::Cache.new)
+      @logio = StringIO.new
+      @website.expect(:logger, Webgen::Logger.new(@logio))
+      @website.expect(:tree, Webgen::Tree.new(@website))
+      @website.ext.item_tracker = Object.new
+      def (@website.ext.item_tracker).add(*args); end
+    end
+
+    # Adds the following nodes (showing alcn=dest_path, title, other meta info) to the tree which
+    # has to be empty:
+    #
+    #   /
+    #   /file.en.html            'file en' sort_info=3
+    #   /file.en.html#frag       'frag'
+    #   /file.en.html#nested     'fragnested'
+    #   /file.de.html            'file de' sort_info=5
+    #   /file.de.html#frag       'frag'
+    #   /other.html              'other'
+    #   /other.en.html           'other en'
+    #   /german.de.html          'german' dest_path='/german.other.html'
+    #   /dir/                    'dir'
+    #   /dir/subfile.html        'subfile'
+    #   /dir/subfile.html#frag   'frag'
+    #   /dir/dir/                'dir'
+    #   /dir/dir/file.html       'file'
+    #   /dir2/                   'dir2' proxy_path='index.html'
+    #   /dir2/index.en.html      'index en' routed_title='routed en' link_attrs={'class' => 'help'}
+    #   /dir2/index.de.html      'index de' routed_title='routed de'
+    def setup_default_nodes(tree)
+      root = Webgen::Node.new(tree.dummy_root, '/', '/')
+
+      file_en = Webgen::Node.new(root, 'file.html', '/file.en.html', {'lang' => 'en', 'title' => 'file en', 'sort_info' => 3})
+      frag_en = Webgen::Node.new(file_en, '#frag', '/file.en.html#frag', {'title' => 'frag'})
+      Webgen::Node.new(frag_en, '#nested', '/file.en.html#nested', {'title' => 'fragnested'})
+      file_de = Webgen::Node.new(root, 'file.html', '/file.de.html', {'lang' => 'de', 'title' => 'file de', 'sort_info' => 5})
+      Webgen::Node.new(file_de, '#frag', '/file.de.html#frag', {'title' => 'frag'})
+
+      Webgen::Node.new(root, 'other.html', '/other.html', {'title' => 'other'})
+      Webgen::Node.new(root, 'other.html', '/other.en.html', {'lang' => 'en', 'title' => 'other en'})
+
+      Webgen::Node.new(root, 'german.html', '/german.other.html', {'title' => 'german', 'lang' => 'de'})
+
+      dir = Webgen::Node.new(root, 'dir/', '/dir/', {'title' => 'dir'})
+      dir_file = Webgen::Node.new(dir, 'subfile.html', '/dir/subfile.html', {'title' => 'subfile'})
+      Webgen::Node.new(dir_file, '#frag', '/dir/subfile.html#frag', {'title' => 'frag'})
+      dir_dir = Webgen::Node.new(dir, 'dir/' , '/dir/dir/', {'title' => 'dir'})
+      Webgen::Node.new(dir_dir, 'file.html', '/dir/dir/file.html', {'title' => 'file'})
+
+      dir2 = Webgen::Node.new(root, 'dir2/', '/dir2/', {'proxy_path' => 'index.html', 'title' => 'dir2'})
+      Webgen::Node.new(dir2, 'index.html', '/dir2/index.en.html',
+                       {'lang' => 'en', 'routed_title' => 'routed', 'title' => 'index en', 'link_attrs' => {'class'=>'help'}})
+      Webgen::Node.new(dir2, 'index.html', '/dir2/index.de.html',
+                       {'lang' => 'de', 'routed_title' => 'routed de', 'title' => 'index de'})
+    end
+
+    # Creates a Webgen::Context object that is returned and accessible via @context.
+    #
+    # The needed website object is created using #setup_website and the :chain is set to a mock
+    # node that responds to :alcn with '/test'.
+    def setup_context
+      setup_website
+      node = MiniTest::Mock.new
+      node.expect(:alcn, '/test')
+      @context = Webgen::Context.new(@website, :chain => [node], :doit => 'hallo')
+    end
+
+    # Creates and returns a RenderNode /tag.template using the default tag template.
+    def setup_tag_template(root)
+      template_data = File.read(File.join(Webgen::Utils.data_dir, 'passive_sources', 'templates', 'tag.template'))
+      RenderNode.new(template_data, root, 'tag.template', '/tag.template')
+    end
+
+  end
+
+end

data/lib/webgen/tree.rb

@@ -1,6 +1,5 @@
 # -*- encoding: utf-8 -*-
 
-require 'webgen/websiteaccess'
 require 'webgen/node'
 
 module Webgen
@@ -8,25 +7,26 @@ module Webgen
   # Represents a tree of nodes.
   class Tree
 
-    include WebsiteAccess
-
-    # The dummy root. This is the default node that gets created when the Tree is created sothat the
-    # real root node can be treated like any other node. It has only one child, namely the real root
-    # node of the tree.
+    # The dummy root.
+    #
+    # This is the default node that gets created when the Tree is created so that the real root node
+    # can be treated like any other node. It has only one child, namely the real root node of the
+    # tree.
     attr_reader :dummy_root
 
-    # Direct access to the hashes for node resolving. Only use this for reading purposes! If you
-    # just want to get a specific node for an alcn/acn/output path, use #node instead.
+    # Direct access to the hashes for node resolving.
+    #
+    # Only use this for reading purposes! If you just want to get a specific node for an
+    # alcn/acn/destination path, use #node instead.
     attr_reader :node_access
 
-    # The hash containing processing information for each node. This is normally not accessed
-    # directly but via the Node#node_info method.
-    attr_reader :node_info
+    # The website to which the Tree object belongs.
+    attr_reader :website
 
-    # Create a new Tree object.
-    def initialize
-      @node_access = {:alcn => {}, :acn => {}, :path => {}}
-      @node_info = {}
+    # Create a new Tree object for the website.
+    def initialize(website)
+      @website = website
+      @node_access = {:alcn => {}, :acn => {}, :dest_path => {}, :translation_key => {}}
       @dummy_root = Node.new(self, '', '')
     end
 
@@ -35,54 +35,103 @@ module Webgen
       @dummy_root.children.first
     end
 
-    # Access a node via a +path+ of a specific +type+. If type is +alcn+ then +path+ has to be an
-    # absolute localized canonical name, if type is +acn+ then +path+ has to be an absolute
-    # canonical name and if type is +path+ then +path+ needs to be an output path.
+    # Access a node via a +path+ of a specific +type+.
+    #
+    # If type is +:alcn+ (default) then +path+ has to be an absolute localized canonical name, if
+    # type is +acn+ then +path+ has to be an absolute canonical name and if type is +:dest_path+
+    # then +path+ needs to be a destination path.
     #
     # Returns the requested Node or +nil+ if such a node does not exist.
     def node(path, type = :alcn)
-      (type == :acn ? @node_access[type][path] && @node_access[type][path].first : @node_access[type][path])
+      case type
+      when :alcn then @node_access[type][path]
+      when :acn then @node_access[type][path] && @node_access[type][path].first
+      when :dest_path then @node_access[type][path]
+      else
+        raise ArgumentError, "Unknown type '#{type}' for resolving path <#{path}>"
+      end
     end
     alias_method :[], :node
 
-    # A utility method called by Node#initialize. This method should not be used directly!
+    # Return the node representing the given +path+ which can be an alcn/acn/destination path (name
+    # resolution is done in the specified order). The path has to be absolute, i.e. starting with a
+    # slash.
+    #
+    # If the +path+ is an alcn and a node is found, it is returned. If the +path+ is an acn, the
+    # correct localized node according to +lang+ is returned or if no such node exists but an
+    # unlocalized version does, the unlocalized node is returned. If the +path+ is a destination
+    # path, the node with this destination path is returned.
+    #
+    # If no node is found for the given path or if the path is invalid, +nil+ is returned and, if
+    # +msg_on_failure+ is +true+, the message :node_resolution_failed (with parameters +path+ and
+    # +lang+) is dispatched.
+    def resolve_node(path, lang, msg_on_failure = false)
+      node = self.node(path, :alcn)
+      if !node || node.acn == path
+        (node = (self.node(path, :acn) || self.node(path + '/', :acn))) && (node = translate_node(node, lang))
+      end
+      node = self.node(path, :dest_path) if !node
+      @website.blackboard.dispatch_msg(:node_resolution_failed, path, lang) if !node && msg_on_failure
+      node
+    end
+
+    # Return the translation of the node to the language +lang+ or, if no such node exists, an
+    # unlocalized version of the node. If no such node is found either, +nil+ is returned.
+    def translate_node(node, lang)
+      avail = @node_access[:translation_key][translation_key(node)]
+      avail.find do |n|
+        n = n.parent while n.is_fragment?
+        n.lang == lang
+      end || avail.find do |n|
+        n = n.parent while n.is_fragment?
+        n.lang.nil?
+      end
+    end
+
+    # Return all translations of the node.
+    def translations(node)
+      @node_access[:translation_key][translation_key(node)].dup
+    end
+
+    # Utility method called by Node#initialize. This method should not be used directly!
     def register_node(node)
       if @node_access[:alcn].has_key?(node.alcn)
-        raise "Can't have two nodes with same absolute lcn: #{node}"
+        raise "Can't have two nodes with same alcn: #{node}"
       else
         @node_access[:alcn][node.alcn] = node
       end
       (@node_access[:acn][node.acn] ||= []) << node
-      register_path(node)
-    end
-
-    # A utility method called by Node#reinit. This method should not be used directly!
-    def register_path(node)
-      return if node['no_output']
-      if @node_access[:path].has_key?(node.path)
-        raise "Can't have two nodes with same output path: #{node.path}"
+      (@node_access[:translation_key][translation_key(node)] ||= []) << node
+      if node.meta_info['no_output']
+        # ignore node dest path
+      elsif @node_access[:dest_path].has_key?(node.dest_path)
+        raise "Can't have two nodes with same destination path: #{node.dest_path}"
       else
-        @node_access[:path][node.path] = node
+        @node_access[:dest_path][node.dest_path] = node
       end
     end
 
-    # Delete the node identified by +node_or_alcn+ and all of its children from the tree.
-    #
-    # The message <tt>:before_node_deleted</tt> is sent with the to-be-deleted node before this node
-    # is actually deleted from the tree.
-    def delete_node(node_or_alcn)
-      n = node_or_alcn.kind_of?(Node) ? node_or_alcn : @node_access[:alcn][node_or_alcn]
-      return if n.nil? || n == @dummy_root
-
-      n.children.dup.each {|child| delete_node(child)}
-
-      website.blackboard.dispatch_msg(:before_node_deleted, n)
-      n.parent.children.delete(n)
-      @node_access[:alcn].delete(n.alcn)
-      @node_access[:acn][n.acn].delete(n)
-      @node_access[:path].delete(n.path)
+    # Return the translation key for the node.
+    def translation_key(node)
+      node.meta_info['translation_key'] || node.acn
+    end
+    private :translation_key
 
-      node_info.delete(n.alcn)
+    # Delete the node and all of its children from the tree.
+    #
+    # The message +:before_node_deleted+ is sent with the to-be-deleted node before the node is
+    # actually deleted from the tree.
+    def delete_node(node)
+      return if node.nil? || !node.kind_of?(Node) || node == @dummy_root
+
+      node.children.dup.each {|child| delete_node(child)}
+
+      @website.blackboard.dispatch_msg(:before_node_deleted, node)
+      node.parent.children.delete(node)
+      @node_access[:alcn].delete(node.alcn)
+      @node_access[:acn][node.acn].delete(node)
+      @node_access[:translation_key][translation_key(node)].delete(node)
+      @node_access[:dest_path].delete(node.dest_path) unless node.meta_info['no_output']
     end
 
   end

data/lib/webgen/utils.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require 'rbconfig'
+require 'webgen/core_ext'
+
+module Webgen
+
+  # Namespace for classes and methods that provide common functionality.
+  module Utils
+
+    # Return the data directory for webgen.
+    def self.data_dir
+      unless defined?(@@data_dir)
+        require 'rbconfig'
+        @@data_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'webgen'))
+        @@data_dir = File.expand_path(File.join(RbConfig::CONFIG["datadir"], "webgen")) if !File.exists?(@@data_dir)
+        raise "Could not find webgen data directory! This is a bug, report it please!" unless File.directory?(@@data_dir)
+      end
+      @@data_dir
+    end
+
+    # Return the object for the given absolute constant +name+.
+    def self.const_for_name(name)
+      name.split('::').inject(Object) {|b,n| b.const_get(n)}
+    end
+
+    # Transform the string in Module::CamelCase format into module/camel_case format.
+    def self.snake_case(str)
+      str = str.dup
+      str.gsub!(/::/, '/')
+      str.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      str.gsub!(/([a-z])([A-Z])/,'\1_\2')
+      str.downcase!
+      str
+    end
+
+  end
+
+end