webgen 1.0.0.beta3 → 1.0.0

data/lib/webgen/content_processor/html_head.rb

@@ -69,10 +69,9 @@ module Webgen
           process_data_array(context, :css_inline) do |content|
             result += "\n<style type=\"text/css\">/*<![CDATA[/*/\n#{content}\n/*]]>*/</style>"
           end
-
-          (context.persistent[:cp_html_head][:meta] || {}).merge(context.content_node['meta'] || {}).each do |name, content|
-            result += "\n<meta name=\"#{ERB::Util.h(name)}\" content=\"#{ERB::Util.h(content)}\" />"
-          end
+        end
+        ((context.persistent[:cp_html_head] || {})[:meta] || {}).merge(context.content_node['meta'] || {}).each do |name, content|
+          result += "\n<meta name=\"#{ERB::Util.h(name)}\" content=\"#{ERB::Util.h(content)}\" />"
         end
         result
       end

data/lib/webgen/content_processor/rainpress.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/content_processor'
+require 'webgen/vendor/rainpress'
+
+module Webgen
+  class ContentProcessor
+
+    # Minifies CSS files.
+    module Rainpress
+
+      # Process the content of +context+ with Rainpress (a CSS minifier).
+      def self.call(context)
+        context.content = ::Rainpress.compress(context.content, context.website.config['content_processor.rainpress.options'])
+        context
+      end
+
+    end
+
+  end
+end

data/lib/webgen/content_processor/sass.rb

@@ -30,9 +30,8 @@ module Webgen
       class NodeTreeImporter < ::Sass::Importers::Base
 
         # Creates a new importer that imports files from the node tree relative to the given node alcn.
-        def initialize(website, alcn)
-          @website = website
-          @alcn = alcn
+        def initialize(context)
+          @context = context
         end
 
         # @see Base#find_relative
@@ -42,11 +41,11 @@ module Webgen
 
         # @see Base#find
         def find(name, options)
-          _find(@alcn, name, options)
+          _find(@context.ref_node.alcn, name, options)
         end
 
         def mtime(name, options) #:nodoc:
-          node = resolve_node(@alcn, name)
+          node = resolve_node(@context.ref_node.alcn, name)
           node['modified_at'] if node
         end
 
@@ -55,7 +54,7 @@ module Webgen
         end
 
         def to_s #:nodoc:
-          "webgen: #{@alcn}"
+          "webgen: #{@context.ref_node.alcn}"
         end
 
         #######
@@ -69,6 +68,7 @@ module Webgen
           node, syntax = resolve_node(base, name)
           return unless node
 
+          @context.website.ext.item_tracker.add(@context.dest_node, :node_content, node)
           options[:syntax] = syntax
           options[:filename] = node.alcn
           options[:importer] = self
@@ -80,7 +80,7 @@ module Webgen
         # Returns [node, syntax] if a node was found or nil otherwise
         def resolve_node(base, path)
           possible_filenames(path).each do |filename, syntax|
-            node = @website.tree.resolve_node(Webgen::Path.append(base, filename), nil)
+            node = @context.website.tree.resolve_node(Webgen::Path.append(base, filename), nil)
             return [node, syntax] if node
           end
           nil
@@ -132,7 +132,7 @@ module Webgen
 
       def self.default_options(context) # :nodoc:
         opts = context.website.config['content_processor.sass.options']
-        load_paths = context.website.ext.sass_load_paths + [NodeTreeImporter.new(context.website, '/')]
+        load_paths = context.website.ext.sass_load_paths + [NodeTreeImporter.new(context)]
         opts.merge({
                      :filename => context.ref_node.alcn,
                      :syntax => :sass,

data/lib/webgen/content_processor/tikz.rb

@@ -23,7 +23,7 @@ module Webgen
         prepare_options(context)
         context.content = context.render_block(:name => 'content',
                                                :chain => [context.website.tree[context['content_processor.tikz.template']]])
-        context.content = File.binread(compile(context))
+        context.content = File.binread(use_cache_or_compile(context))
         context
       end
 
@@ -38,48 +38,91 @@ module Webgen
       end
       private_class_method :prepare_options
 
+      # Checks whether a cached version exists and if it is usable. If not, the LaTeX document is
+      # compiled.
+      def self.use_cache_or_compile(context)
+        cwd = context.website.tmpdir('content_processor.tikz')
+        FileUtils.mkdir_p(cwd)
+
+        tex_file = File.join(cwd, context.dest_node.dest_path.tr('/', '_').sub(/\..*?$/, '.tex'))
+        basename = File.basename(tex_file, '.tex')
+        ext = File.extname(context.dest_node.dest_path)
+        image_file = tex_file.sub(/\.tex$/, ext)
+
+        if !cache_usable?(context, tex_file, image_file)
+          compile(context, cwd, tex_file, basename, ext)
+          save_cache(context, tex_file)
+        end
+
+        image_file
+      end
+      private_class_method :use_cache_or_compile
+
       # Compile the LaTeX document stored in the Context and convert the resulting PDF to the
       # correct output image format specified by context[:ext] (the extension needs to include the
       # dot).
       #
       # Returns the path to the created image.
-      def self.compile(context)
-        cwd = context.website.tmpdir('content_processor.tikz')
-        tex_file = File.join(cwd, context.dest_node.dest_path.tr('/', '_').sub(/\..*?$/, '.tex'))
-        FileUtils.mkdir_p(cwd)
-        File.write(tex_file, context.content)
-
-        file = File.basename(tex_file, '.tex')
-        ext = File.extname(context.dest_node.dest_path)
+      def self.compile(context, cwd, tex_file, basename, ext)
         render_res, output_res = context['content_processor.tikz.resolution'].split(' ')
 
-        execute("pdflatex -shell-escape -interaction=nonstopmode -halt-on-error #{file}.tex", cwd, context) do |status, stdout, stderr|
+        File.write(tex_file, context.content)
+        execute("pdflatex -shell-escape -interaction=nonstopmode -halt-on-error #{basename}.tex", cwd, context) do |status, stdout, stderr|
           errors = (stdout+stderr).scan(/^!(.*\n.*)/).join("\n")
           raise Webgen::RenderError.new("Error while parsing TikZ picture commands with PDFLaTeX: #{errors}",
                                         'content_processor.tikz', context.dest_node, context.ref_node)
         end
 
-        execute("pdfcrop #{file}.pdf #{file}.pdf", cwd, context)
+        execute("pdfcrop #{basename}.pdf #{basename}.pdf", cwd, context)
 
         if context['content_processor.tikz.transparent'] && ext =~ /\.png/i
           cmd = "gs -dSAFER -dBATCH -dNOPAUSE -r#{render_res} -sDEVICE=pngalpha -dGraphicsAlphaBits=4 " +
-            "-dTextAlphaBits=4 -sOutputFile=#{file}#{ext} #{file}.pdf"
+            "-dTextAlphaBits=4 -sOutputFile=#{basename}#{ext} #{basename}.pdf"
         else
-          cmd = "convert -density #{render_res} #{file}.pdf #{file}#{ext}"
+          cmd = "convert -density #{render_res} #{basename}.pdf #{basename}#{ext}"
         end
         execute(cmd, cwd, context)
 
         if render_res != output_res
-          status, stdout, stderr = execute("identify #{file}#{ext}", cwd, context)
+          status, stdout, stderr = execute("identify #{basename}#{ext}", cwd, context)
           width, height = stdout.scan(/\s\d+x\d+\s/).first.strip.split('x').collect do |s|
             s.to_f * output_res.to_f / render_res.to_f
           end
-          execute("convert -resize #{width}x#{height} #{file}#{ext} #{file}#{ext}", cwd, context)
+          execute("convert -resize #{width}x#{height} #{basename}#{ext} #{basename}#{ext}", cwd, context)
         end
-        File.join(cwd, file + ext)
       end
       private_class_method :compile
 
+      # Save cache data so that it is possible to use it the next time.
+      def self.save_cache(context, tex_file)
+        File.write(cache_file(tex_file), cache_data(context))
+      end
+      private_class_method :save_cache
+
+      # Check if the content of the LaTeX document or the used options have changed.
+      def self.cache_usable?(context, tex_file, image_file)
+        cfile = cache_file(tex_file)
+        File.exist?(image_file) && File.exist?(cfile) && File.binread(cfile) == cache_data(context)
+      end
+      private_class_method :cache_usable?
+
+      # The data that should be written to the cache file.
+      def self.cache_data(context)
+        ("" << context.content <<
+          "\n" << context['content_processor.tikz.resolution'].to_s <<
+          "\n" << context['content_processor.tikz.transparent'].to_s <<
+          "\n" << context['content_processor.tikz.libraries'].to_s <<
+          "\n" << context['content_processor.tikz.opts'].to_s <<
+          "\n" << context['content_processor.tikz.template'].to_s).force_encoding('BINARY')
+      end
+      private_class_method :cache_data
+
+      # Return the name of the cache file for the give LaTeX file.
+      def self.cache_file(tex_file)
+        tex_file.sub(/\.tex$/, ".cache")
+      end
+      private_class_method :cache_file
+
       # Execute the command +cmd+ in the working directory +cwd+.
       #
       # If the exit status is not zero, yields to the given block if one is given, or raises an error

data/lib/webgen/item_tracker.rb

@@ -30,7 +30,9 @@ module Webgen
   #   tracker extension
   #
   # [item_data(*item)]
-  #   Return the data for the item so that it can be correctly checked later if it has changed.
+  #   Return the data for the item so that it can be correctly checked later if it has changed. If
+  #   data for the given item cannot be computer anymore because the item got invalid, raise an
+  #   exception.
   #
   # [item_changed?(item_id, old_data)]
   #   Return +true+ if the item identified by its unique ID has changed. The parameter +old_data+
@@ -106,42 +108,60 @@ module Webgen
 
       @item_changed = {}
 
-      @website.blackboard.add_listener(:website_initialized, self) do
+      @website.blackboard.add_listener(:website_initialized, 'item_tracker') do
         @cached = @website.cache[:item_tracker_data] || @cached
       end
 
-      @website.blackboard.add_listener(:after_tree_populated, self) do |node|
+      @website.blackboard.add_listener(:after_tree_populated, 'item_tracker') do |node|
         @item_data.keys.each do |uid|
           @item_data[uid] = item_tracker(uid.first).item_data(*uid.last)
         end
       end
 
-      @website.blackboard.add_listener(:before_all_nodes_written, self) do
-        # make all used item data from the previous pass current again if applicable
-        @written_nodes.each do |node|
+      @website.blackboard.add_listener(:before_all_nodes_written, 'item_tracker') do
+        # make all used item data from the previous pass current again if applicable and remove
+        # invalid UIDs
+        uids_to_update = @written_nodes.each_with_object(Set.new) do |node, set|
           next unless @website.tree[node.alcn]
-          @node_dependencies[node.alcn].each do |uid|
+          set.merge(@node_dependencies[node.alcn])
+        end
+        uids_to_update.each do |uid|
+          begin
             @item_data[uid] = item_tracker(uid.first).item_data(*uid.last)
+          rescue Exception
+            @item_data.delete(uid)
+            @cached[:item_data].delete(uid)
+            @written_nodes.each do |node|
+              if @node_dependencies[node.alcn].include?(uid)
+                @node_dependencies[node.alcn].delete(uid)
+                @cached[:node_dependencies][node.alcn].delete(uid)
+                node.node_info[:item_tracker_changed_once] = true
+              end
+            end
           end
         end
+
         @written_nodes = []
         @item_changed = {}
       end
 
-      @website.blackboard.add_listener(:after_node_written, self) do |node|
+      @website.blackboard.add_listener(:after_node_written, 'item_tracker') do |node|
         @written_nodes << node
       end
 
-      @website.blackboard.add_listener(:after_all_nodes_written, self) do
+      @website.blackboard.add_listener(:after_all_nodes_written, 'item_tracker') do
         # update cached data with data from the run
+        uids_to_update = Set.new
         @written_nodes.each do |node|
           next unless @website.tree[node.alcn]
+          node.node_info.delete(:item_tracker_changed_once)
           @cached[:node_dependencies][node.alcn] = @node_dependencies[node.alcn]
-          @node_dependencies[node.alcn].each {|uid| @cached[:item_data][uid] = @item_data[uid]}
+          uids_to_update.merge(@node_dependencies[node.alcn])
         end
+        uids_to_update.each {|uid| @cached[:item_data][uid] = @item_data[uid]}
       end
 
-      @website.blackboard.add_listener(:website_generated, self) do
+      @website.blackboard.add_listener(:website_generated, 'item_tracker') do
         @cached[:node_dependencies].reject! {|alcn, data| !@website.tree[alcn]}
 
         used_uids = @cached[:node_dependencies].each_with_object(Set.new) {|(_, uids), obj| obj.merge(uids)}
@@ -189,7 +209,8 @@ module Webgen
     def node_changed?(node)
       return false if @checked_nodes.include?(node)
       @checked_nodes << node
-      !@cached[:node_dependencies].has_key?(node.alcn) ||
+      node.node_info[:item_tracker_changed_once] ||
+        !@cached[:node_dependencies].has_key?(node.alcn) ||
         @cached[:node_dependencies][node.alcn].any? {|uid| item_changed_by_uid?(uid)}
     ensure
       @checked_nodes.delete(node)

data/lib/webgen/item_tracker/missing_node.rb

@@ -23,13 +23,13 @@ module Webgen
         @stop_reporting = false
         @nodes_to_ignore = Set.new
 
-        @website.blackboard.add_listener(:reused_existing_node, self) do |node, path|
+        @website.blackboard.add_listener(:reused_existing_node, 'item_tracker.missing_node') do |node, path|
           @nodes_to_ignore << node
         end
-        @website.blackboard.add_listener(:after_node_created, self) do |node|
+        @website.blackboard.add_listener(:after_node_created, 'item_tracker.missing_node') do |node|
           @at_least_one_node_created = true unless @nodes_to_ignore.include?(node)
         end
-        @website.blackboard.add_listener(:after_all_nodes_written, self) do
+        @website.blackboard.add_listener(:after_all_nodes_written, 'item_tracker.missing_node') do
           if @at_least_one_node_created
             @at_least_one_node_created = false
           else
@@ -37,7 +37,7 @@ module Webgen
           end
           @nodes_to_ignore = Set.new
         end
-        @website.blackboard.add_listener(:website_generated, self) do
+        @website.blackboard.add_listener(:website_generated, 'item_tracker.missing_node') do
           @at_least_one_node_created = true
           @stop_reporting = false
           @nodes_to_ignore = Set.new
@@ -63,7 +63,7 @@ module Webgen
       end
 
       def item_description(iid, data) #:nodoc:
-        path, lang = *iid.last
+        path, lang = iid
         "Missing acn, alcn or dest path <#{path}>" << (lang.nil? ? '' : " in language '#{lang}'")
       end
 

data/lib/webgen/item_tracker/template_chain.rb

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/item_tracker'
+
+module Webgen
+  class ItemTracker
+
+    # This class is used to track the template chain for a node.
+    #
+    # Note that only nodes that support the #template_chain method can be used (so all page,
+    # template and custom webgen nodes are okay).
+    #
+    # The item for this tracker is the node whose template chain should be tracked, i.e. add an item
+    # like this:
+    #
+    #   website.ext.item_tracker.add(some_node, :template_chain, other_node)
+    #
+    class TemplateChain
+
+      def initialize(website) #:nodoc:
+        @website = website
+      end
+
+      def item_id(node) #:nodoc:
+        node.alcn
+      end
+
+      def item_data(alcn) #:nodoc:
+        nodes_to_alcn(@website.tree[alcn].template_chain)
+      end
+
+      def item_changed?(alcn, old_chain) #:nodoc:
+        @website.tree[alcn].nil? || item_data(alcn) != old_chain
+      end
+
+      def referenced_nodes(alcn, data) #:nodoc:
+        [alcn]
+      end
+
+      def item_description(alcn, data) #:nodoc:
+        "Template chain for node '#{alcn}'"
+      end
+
+      def nodes_to_alcn(nodes) #:nodoc:
+        nodes.map {|node| node.alcn}
+      end
+      private :nodes_to_alcn
+
+    end
+
+  end
+end

data/lib/webgen/misc/dummy_index.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+require 'yaml'
+require 'webgen/error'
+
+module Webgen
+
+  module Misc
+
+    # This extension creates dummy directory index paths for directories where the proxy_path meta
+    # information does not point to a node whose lcn matches a directory index path name.
+    class DummyIndex
+
+      def initialize(website) #:nodoc:
+        @website = website
+
+        @website.blackboard.add_listener(:website_initialized, 'misc.dummy_index') do
+          if @website.config['misc.dummy_index.enabled'] && @website.config['misc.dummy_index.directory_indexes'].length > 0
+            @website.blackboard.add_listener(:website_generated, 'misc.dummy_index', &method(:create_dummy_indexes))
+          end
+        end
+      end
+
+      # Create the dummy index paths at the destination.
+      def create_dummy_indexes
+        indexes = @website.config['misc.dummy_index.directory_indexes']
+        @website.tree.node_access[:alcn].each do |_, node|
+          next if !node.is_directory? || !directory_exists?(node) || directory_index_exists?(node, indexes)
+
+          route = node.route_to(node)
+          route = node['proxy_path'].to_s if route == File.basename(node.dest_path)
+          index_path = node.dest_path + indexes.first
+
+          next if route == '' || indexes.any? {|index| index == route} ||
+            (cache[node.alcn] == [indexes.first, route] && @website.ext.destination.exists?(index_path))
+
+          @website.logger.info do
+            "[#{@website.ext.destination.exists?(index_path) ? 'update' : 'create'}] <#{index_path}> (dummy directory path pointing to #{route})"
+          end
+          cache[node.alcn] = [indexes.first, route]
+          @website.ext.destination.write(index_path, dummy_index_content(route))
+        end
+      end
+      protected :create_dummy_indexes
+
+      # Does the node directory exist at the destination?
+      def directory_exists?(node)
+        @website.ext.destination.exists?(node.dest_path)
+      end
+      protected :directory_exists?
+
+      # Is there any node with a destination path matching any of the directory index paths?
+      def directory_index_exists?(node, indexes) #:nodoc:
+        indexes.any? {|index| @website.tree.node(node.dest_path + index, :dest_path)}
+      end
+      protected :directory_index_exists?
+
+      # Return the dummy index path content for redirecting to +url+.
+      def dummy_index_content(url)
+        <<EOF
+<!DOCTYPE html><html><head><title>Redirect</title><meta charset="UTF-8" />
+<meta http-equiv="Refresh" content="0; url=#{url}" />
+</head><body></body></html>
+EOF
+      end
+      protected :dummy_index_content
+
+      # Return the cache used by this extension.
+      def cache
+        @website.cache['misc.dummy_index.data'] ||= {}
+      end
+      protected :cache
+
+    end
+
+  end
+
+end