webgen 0.5.0 → 0.5.1

data/lib/webgen/default_config.rb

@@ -60,13 +60,7 @@ config.sourcehandler.casefold(true, :doc => 'Specifies whether path are consider
 config.sourcehandler.use_hidden_files(false, :doc => 'Specifies whether hidden files (those starting with a dot) are used')
 config.sourcehandler.ignore(['**/*~', '**/.svn/**'], :doc => 'Path patterns that should be ignored')
 config.sourcehandler.default_lang_in_output_path(false, :doc => 'Specifies whether output paths in the default language should have the language in the name')
-=begin
-TODO:put this info into the user docs
-      desc: Defines how the output name should be built. The correct name will be used for the
-            :basename part and the file language will be used for the :lang part. If defaultLangInFilename
-            is true, the :lang part or the subarray in which the :lang part was defined, will be omitted.
-            The :ext part is replaced with the correct extension.
-=end
+
 config.sourcehandler.default_meta_info({
                                          :all => {
                                            'output_path_style' => [:parent, :cnbase, ['.', :lang], :ext]
@@ -76,10 +70,10 @@ config.sourcehandler.default_meta_info({
                                          },
                                          'Webgen::SourceHandler::Page' => {
                                            'fragments_in_menu' => true,
-                                           'blocks' => {'default' => {'pipeline' => 'tags,maruku,blocks'}}
+                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,maruku,blocks'}}
                                          },
                                          'Webgen::SourceHandler::Template' => {
-                                           'blocks' => {'default' => {'pipeline' => 'tags,blocks'}}
+                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,blocks'}}
                                          },
                                          'Webgen::SourceHandler::Metainfo' => {
                                            'blocks' => {1 => {'name' => 'paths'}, 2 => {'name' => 'alcn'}}
@@ -105,7 +99,12 @@ config.contentprocessor.map({
                               'maruku' => 'Webgen::ContentProcessor::Maruku',
                               'redcloth' => 'Webgen::ContentProcessor::RedCloth',
                               'tags' => 'Webgen::ContentProcessor::Tags',
-                              'blocks' => 'Webgen::ContentProcessor::Blocks'
+                              'blocks' => 'Webgen::ContentProcessor::Blocks',
+                              'erb' => 'Webgen::ContentProcessor::Erb',
+                              'haml' => 'Webgen::ContentProcessor::Haml',
+                              'sass' => 'Webgen::ContentProcessor::Sass',
+                              'rdoc' => 'Webgen::ContentProcessor::RDoc',
+                              'builder' => 'Webgen::ContentProcessor::Builder',
                             }, :doc => 'Content processor name to class map')
 
 Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_names, Webgen::ContentProcessor.method(:list))
@@ -116,6 +115,12 @@ config.contentprocessor.tags.prefix('', :doc => 'The prefix used for tag names t
 config.contentprocessor.tags.map({
                                    'relocatable' => 'Webgen::Tag::Relocatable',
                                    'menu' => 'Webgen::Tag::Menu',
+                                   'breadcrumb_trail' => 'Webgen::Tag::BreadcrumbTrail',
+                                   'langbar' => 'Webgen::Tag::Langbar',
+                                   'include_file' => 'Webgen::Tag::IncludeFile',
+                                   'execute_cmd' => 'Webgen::Tag::ExecuteCommand',
+                                   'coderay' => 'Webgen::Tag::Coderay',
+                                   'date' => 'Webgen::Tag::Date',
                                    :default => 'Webgen::Tag::Metainfo'
                                  }, :doc => 'Tag processor name to class map')
 
@@ -126,3 +131,29 @@ config.tag.menu.min_levels(1, :doc => 'The minimum number of menu levels that sh
 config.tag.menu.max_levels(3, :doc => 'The maximum number of menu levels that should be shown.')
 config.tag.menu.show_current_subtree_only(true, :doc => 'Specifies whether only the current subtree should be shown.')
 config.tag.menu.used_nodes('all', :doc => 'Specifies the kind of nodes that should be used: all, files, or fragments')
+
+config.tag.breadcrumbtrail.separator(' / ', :doc => 'Separates the hierachy entries from each other.')
+config.tag.breadcrumbtrail.omit_last(false, :doc => 'Omits the last path component.')
+config.tag.breadcrumbtrail.omit_index_path(false, :doc => 'Omits the last path component if it is an index path.')
+
+config.tag.langbar.separator(' | ', :doc => 'Separates the languages from each other.')
+config.tag.langbar.show_single_lang(true, :doc => 'Should the link be shown although the page is only available in one language?')
+config.tag.langbar.show_own_lang(true, :doc => 'Should the link to the currently displayed language page be shown?')
+
+config.tag.includefile.filename(nil, :doc => 'The name of the file which should be included (relative to the website).', :mandatory => 'default')
+config.tag.includefile.process_output(true, :doc => 'The file content will be scanned for tags if true.')
+config.tag.includefile.escape_html(true, :doc => 'Special HTML characters in the file content will be escaped if true.')
+
+config.tag.executecommand.command(nil, :doc => 'The command which should be executed', :mandatory => 'default')
+config.tag.executecommand.process_output(true, :doc => 'The output of the command will be scanned for tags if true')
+config.tag.executecommand.escape_html(true, :doc => 'Special HTML characters in the output will be escaped if true')
+
+config.tag.coderay.lang('ruby', :doc => 'The highlighting language', :mandatory => 'default')
+config.tag.coderay.process_body(true, :doc => 'The tag body will be scanned for tags first if true')
+config.tag.coderay.wrap(:div, :doc => 'Specifies how the code should be wrapped, either :div or :span')
+config.tag.coderay.line_numbers(true, :doc => 'Show line numbers')
+config.tag.coderay.line_number_start(1, :doc => 'Line number of first line')
+config.tag.coderay.bold_every(10, :doc => 'The interval at which the line number appears bold')
+config.tag.coderay.tab_width(8, :doc => 'Number of spaces used for a tabulator')
+
+config.tag.date.format('%Y-%m-%d %H:%M:%S', :doc => 'The format of the date (same options as Ruby\'s Time#strftime)')

data/lib/webgen/node.rb

@@ -267,10 +267,11 @@ module Webgen
     # always need to specify general attributes with Strings!
     def link_to(node, attr = {})
       attr = node['link_attrs'].merge(attr) if node['link_attrs'].kind_of?(Hash)
-      link_text = attr[:link_text] || node.routing_node(@lang)['routed_title'] || node['title']
+      rnode = node.routing_node(@lang)
+      link_text = attr[:link_text] || (rnode != node && rnode['routed_title']) || node['title']
       attr.delete_if {|k,v| k.kind_of?(Symbol)}
 
-      use_link = (node != self || website.config['website.link_to_current_page'])
+      use_link = (rnode != self || website.config['website.link_to_current_page'])
       attr['href'] = self.route_to(node) if use_link
       attrs = attr.collect {|name,value| "#{name.to_s}=\"#{value}\"" }.sort.unshift('').join(' ')
       (use_link ? "<a#{attrs}>#{link_text}</a>" : "<span#{attrs}>#{link_text}</span>")

data/lib/webgen/path.rb

@@ -6,7 +6,8 @@ module Webgen
   # content.
   #
   # A webgen source class needs to derive a specialized path class from this class and implement an
-  # approriate #changed? method.
+  # approriate #changed? method that returns +true+ if the path's content has changed since the last
+  # webgen run.
   class Path
 
     # Helper class for easy access to the content of a path.
@@ -74,6 +75,12 @@ module Webgen
       temp
     end
 
+    # Has the content of this path changed since the last webgen run? This default implementation
+    # always returns +true+, a specialized sub class needs to override this behaviour!
+    def changed?
+      true
+    end
+
     # Duplicate the path object.
     def dup
       temp = super

data/lib/webgen/sourcehandler.rb

@@ -58,16 +58,21 @@ module Webgen
           tree.node_access[:alcn].sort.each do |name, node|
             next if node == tree.dummy_root || !node.dirty
             node.dirty = node.created = false
-            if !node['no_output'] && (content = node.content)
-              puts " "*4 + name, :verbose
-              type = if node.is_directory?
-                       :directory
-                     elsif node.is_fragment?
-                       :fragment
-                     else
-                       :file
-                     end
-              output.write(node.path, content, type)
+
+            begin
+              if !node['no_output'] && (content = node.content)
+                puts " "*4 + name, :verbose
+                type = if node.is_directory?
+                         :directory
+                       elsif node.is_fragment?
+                         :fragment
+                       else
+                         :file
+                       end
+                output.write(node.path, content, type)
+              end
+            rescue
+              raise RuntimeError, "Error while processing <#{node.absolute_lcn}>: #{$!.message}", $!.backtrace
             end
           end
         end

data/lib/webgen/sourcehandler/page.rb

@@ -19,8 +19,16 @@ module Webgen::SourceHandler
         node.node_info[:page] = page
         tmp_logger = website.logger
         website.logger = nil    # disabling logging whiling creating fragment nodes
+
+        website.cache.permanent[:page_sections] ||= {}
+        sections = if path.changed? || !website.cache.permanent[:page_sections][node.absolute_lcn]
+                     website.blackboard.invoke(:parse_html_headers, render_node(node, 'content', []))
+                   else
+                     website.cache.permanent[:page_sections][node.absolute_lcn]
+                   end
+        website.cache.permanent[:page_sections][node.absolute_lcn] = sections
         website.blackboard.invoke(:create_fragment_nodes,
-                                  website.blackboard.invoke(:parse_html_headers, render_node(node, 'content', [])),
+                                  sections,
                                   node, node.meta_info['fragments_in_menu'])
         website.logger = tmp_logger
       end

data/lib/webgen/tag.rb

@@ -10,6 +10,12 @@ module Webgen
     autoload :Relocatable, 'webgen/tag/relocatable'
     autoload :Metainfo, 'webgen/tag/metainfo'
     autoload :Menu, 'webgen/tag/menu'
+    autoload :BreadcrumbTrail, 'webgen/tag/breadcrumbtrail'
+    autoload :Langbar, 'webgen/tag/langbar'
+    autoload :IncludeFile, 'webgen/tag/includefile'
+    autoload :ExecuteCommand, 'webgen/tag/executecommand'
+    autoload :Coderay, 'webgen/tag/coderay'
+    autoload :Date, 'webgen/tag/date'
 
   end
 

data/lib/webgen/tag/breadcrumbtrail.rb

@@ -0,0 +1,39 @@
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Generates a breadcrumb trail for the page. This is especially useful when pages are in deep
+  # hierarchies of directories.
+  class BreadcrumbTrail
+
+    include Webgen::Tag::Base
+
+    # Create the breadcrumb trail.
+    def call(tag, body, context)
+      out = []
+      node = context.content_node
+
+      omit_index_path = if node.meta_info.has_key?('omit_index_path')
+                          node['omit_index_path']
+                        else
+                          param('tag.breadcrumbtrail.omit_index_path')
+                        end
+      omit_index_path = omit_index_path && node.parent.routing_node(node.lang) == node
+
+      node = node.parent if omit_index_path
+
+      until node == node.tree.dummy_root
+        context.dest_node.node_info[:used_nodes] << node.routing_node(context.dest_node.lang).absolute_lcn
+        context.dest_node.node_info[:used_nodes] << node.absolute_lcn
+        out.push(context.dest_node.link_to(node.in_lang(context.content_node.lang)))
+        node = node.parent
+      end
+      out[0] = '' if param('tag.breadcrumbtrail.omit_last') && !omit_index_path
+      out = out.reverse.join(param('tag.breadcrumbtrail.separator'))
+      log(:debug) { "Breadcrumb trail for <#{context.dest_node.absolute_lcn}>: #{out}" }
+      out
+    end
+
+  end
+
+end

data/lib/webgen/tag/coderay.rb

@@ -0,0 +1,32 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Provides syntax highlighting via the +coderay+ library.
+  class Coderay
+
+    include Webgen::Tag::Base
+    include Webgen::WebsiteAccess
+
+    # Highlight the body of the block.
+    def call(tag, body, context)
+      require 'coderay'
+      options = {
+        :css => :style,
+        :wrap => param('tag.coderay.wrap').to_sym,
+        :line_numbers => (param('tag.coderay.line_numbers') ? :inline : nil),
+        :line_number_start => param('tag.coderay.line_number_start'),
+        :tab_width => param('tag.coderay.tab_width'),
+        :bold_every => param('tag.coderay.bold_every')
+      }
+
+      if param('tag.coderay.process_body')
+        body = website.blackboard.invoke(:content_processor, 'tags').call(context.clone(:content => body)).content
+      end
+      CodeRay.scan(body, param('tag.coderay.lang').to_sym).html(options)
+    end
+
+  end
+
+end

data/lib/webgen/tag/date.rb

@@ -0,0 +1,18 @@
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Prints out the date using a format string which will be passed to Time#strftime. Therefore you
+  # can use everything Time#strftime offers.
+  class Date
+
+    include Base
+
+    # Return the current date formatted as specified.
+    def call(tag, body, context)
+      Time.now.strftime(param('tag.date.format'))
+    end
+
+  end
+
+end

data/lib/webgen/tag/executecommand.rb

@@ -0,0 +1,26 @@
+require 'webgen/tag'
+require 'cgi'
+require "tempfile"
+
+module Webgen::Tag
+
+  # Executes the given command and returns the standard output. All special HTML characters are
+  # escaped.
+  class ExecuteCommand
+
+    include Webgen::Tag::Base
+
+    # Execute the command and return the standard output.
+    def call(tag, body, context)
+      command = param('tag.executecommand.command')
+      output = `#{command} 2> /dev/null`
+      if ($? >> 8) != 0
+        raise "Command '#{command}' in <#{context.ref_node.absolute_lcn}> has return value != 0: #{output}"
+      end
+      output = CGI::escapeHTML(output) if param('tag.executecommand.escape_html')
+      [output, param('tag.executecommand.process_output')]
+    end
+
+  end
+
+end

data/lib/webgen/tag/includefile.rb

@@ -0,0 +1,42 @@
+require 'webgen/websiteaccess'
+require 'webgen/tag'
+require 'cgi'
+
+module Webgen::Tag
+
+  # Includes a file verbatim and optionally escapes all special HTML characters and processes webgen
+  # tags in it.
+  class IncludeFile
+
+    include Webgen::Tag::Base
+    include Webgen::WebsiteAccess
+
+    def initialize #:nodoc:
+      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
+    end
+
+    # Include the specified file verbatim in the output, optionally escaping special HTML characters
+    # and processing tags in it.
+    def call(tag, body, context)
+      filename = param('tag.includefile.filename')
+      filename = File.join(website.directory, filename) unless filename =~ /^(\/|\w:)/
+      content = File.read(filename)
+      content = CGI::escapeHTML(content) if param('tag.includefile.escape_html')
+      (context.dest_node.node_info[:tag_includefile_filenames] ||= []) << [filename, File.mtime(filename)]
+
+      [content, param('tag.includefile.process_output')]
+    end
+
+    #######
+    private
+    #######
+
+    def node_changed?(node)
+      if filenames = node.node_info[:tag_includefile_filenames]
+        node.dirty = true if filenames.any? {|f, mtime| File.mtime(f) > mtime}
+      end
+    end
+
+  end
+
+end

data/lib/webgen/tag/langbar.rb

@@ -0,0 +1,24 @@
+require 'webgen/tag'
+
+module Webgen::Tag
+
+  # Generates a list with all the languages of the page.
+  class Langbar
+
+    include Webgen::Tag::Base
+
+    # Return a list of all translations of the content page.
+    def call(tag, body, context)
+      lang_nodes = context.content_node.tree.node_access[:acn][context.content_node.absolute_cn]
+      nr_langs = lang_nodes.length
+      result = lang_nodes.
+        reject {|n| (context.content_node.lang == n.lang && !param('tag.langbar.show_own_lang')) }.
+        sort {|a, b| a.lang <=> b.lang}.
+        collect {|n| context.dest_node.link_to(n, :link_text => n.lang)}.
+        join(param('tag.langbar.separator'))
+      (param('tag.langbar.show_single_lang') || nr_langs > 1 ? result : "")
+    end
+
+  end
+
+end

data/lib/webgen/tag/metainfo.rb

@@ -15,7 +15,7 @@ module Webgen::Tag
       elsif context.content_node[tag]
         output = context.content_node[tag].to_s
       else
-        log(:warn) { "No value for tag '#{tag}' in <#{context.ref_node.absolute_lcn}> found in <#{context.content_node.absolute_lcn}>" }
+        log(:warn) { "No value for meta info key '#{tag}' in <#{context.ref_node.absolute_lcn}> found in <#{context.content_node.absolute_lcn}>" }
       end
       output
     end

data/lib/webgen/version.rb

@@ -1,6 +1,6 @@
 module Webgen
 
   # The version of webgen.
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 
 end

data/lib/webgen/webgentask.rb

@@ -125,16 +125,11 @@ module Webgen
     def define # :nodoc:
       desc "Render the webgen website"
       task @name, :verbosity, :log_level do |t, args|
-        begin
-          require 'webgen/website'
-          website = Webgen::Website.new(@directory, Webgen::Logger.new($stdout), &@config_block)
-          website.logger.verbosity = args[:verbosity].to_s.intern unless args[:verbosity].to_s.empty?
-          website.logger.level = args[:log_level].to_i if args[:log_level]
-          website.render
-        rescue => e
-          puts "webgen task failed: #{e}"
-          raise e
-        end
+        require 'webgen/website'
+        website = Webgen::Website.new(@directory, Webgen::Logger.new($stdout), &@config_block)
+        website.logger.verbosity = args[:verbosity].to_s.intern unless args[:verbosity].to_s.empty?
+        website.logger.level = args[:log_level].to_i if args[:log_level]
+        website.render
       end
 
       task :clobber => paste('clobber_', @name)

data/misc/default.css

@@ -307,6 +307,25 @@ blockquote pre {
   padding: 2px;
 }
 
+/* extensions classes */
+.backlink {
+  float: right;
+}
+
+table.examples {
+  border: 1px solid black;
+  border-collapse: collapse;
+  margin-left: auto;
+  margin-right: auto;
+  width: 80%;
+}
+
+table.examples td, table.examples th {
+  border: 1px solid black;
+  padding: 3px;
+}
+
+
 
 /* plugin documentation classes */
 .plugin-info .param-name {

data/misc/default.template

@@ -58,12 +58,14 @@
 
       <div class="col2 float-right">
         <p>
-          &copy; 2007 Thomas Leitner | generated by <a href="http://webgen.rubyforge.org">webgen</a><br />
+          &copy; 2008 Thomas Leitner | generated by <a href="http://webgen.rubyforge.org">webgen</a><br />
           Design based on Ablaze 2.1 by <a href="http://www.styleshout.com/">styleshout</a><br />
           Block quote icons originally by <a href="http://fullahead.org/">Fullahead</a><br />
           Valid <a href="http://jigsaw.w3.org/css-validator/check/referer">CSS</a> |
           <a href="http://validator.w3.org/check/referer">XHTML</a>
         </p>
+
+        <p>Page last changed at: {date:}</p>
       </div>
 
     </div></div>