webgen 1.0.0.beta3 → 1.0.0

data/lib/webgen/bundle/built-in/init.rb

@@ -30,26 +30,31 @@ is_integer = lambda do |val|
   val
 end
 
+symbolic_hash = lambda do |val|
+  raise 'The value has to be a hash' unless val.kind_of?(Hash)
+  val.each_with_object({}) {|(k,v), h| h[k.to_sym] = v}
+end
+
 ########################################################################
 # General configuration parameters
 
-option('website.tmpdir', 'tmp',
-       'Storage location relative to website directory for cache and temporary files created when webgen is run', &is_string)
-option('website.cache', [:file, 'webgen.cache'],
-       'The file name relative to website.tmpdir (or a string) from/to which the cache is read/written') do |val|
+option('website.tmpdir', 'tmp', &is_string)
+option('website.cache', ['file', 'webgen.cache']) do |val|
   raise "The value has to be an array with two values" unless val.kind_of?(Array) && val.length == 2
-  raise "The first value has to be :file or :string" unless val[0] == :file || val[0] == :string
+  val.map! {|v| v.to_s}
+  raise "The first value has to be 'file' or 'string'" unless val[0] == 'file' || val[0] == 'string'
   val
 end
-option('website.dry_run', false,
-       "Perform a dry run, don't actually write files", &true_or_false)
+option('website.dry_run', false, &true_or_false)
 
-option('website.lang', 'en', 'The default language used for the website') do |val|
+option('website.lang', 'en') do |val|
   lang = LanguageManager.language_for_code(val)
   raise "Unknown language code '#{val}'" if lang.nil?
   lang
 end
 
+option('website.base_url', '', &is_string)
+
 
 ########################################################################
 # Everything related to the content processor extension
@@ -59,67 +64,56 @@ website.ext.content_processor = content_processor = Webgen::ContentProcessor.new
 content_processor.register('Blocks')
 content_processor.register('Builder')
 content_processor.register('Erb')
-option('content_processor.erb.trim_mode', '',
-       "Specifies the ERB trim mode, can contain any combination of '%', '<' and '<>'", &is_string)
+option('content_processor.erb.trim_mode', '', &is_string)
 
 content_processor.register('Erubis')
-option('content_processor.erubis.use_pi', false,
-       'Specifies whether processing instructions should be used', &true_or_false)
-option('content_processor.erubis.options', {},
-       'A hash of additional, erubis specific options')
+option('content_processor.erubis.use_pi', false, &true_or_false)
+option('content_processor.erubis.options', {}, &symbolic_hash)
 
 content_processor.register('Fragments')
 content_processor.register('Haml', :ext_map => {'haml' => 'html'})
 content_processor.register('HtmlHead')
 
 content_processor.register('Kramdown')
-option('content_processor.kramdown.options', {:auto_ids => true},
-       'The options hash for the kramdown processor')
-option('content_processor.kramdown.handle_links', true,
-       'Whether all links in a kramdown document should be processed by webgen', &true_or_false)
-option('content_processor.kramdown.ignore_unknown_fragments', false,
-       'Specifies whether unknown, non-resolvable fragment parts should be ignored when handling links', &true_or_false)
+option('content_processor.kramdown.options', {:auto_ids => true}, &symbolic_hash)
+option('content_processor.kramdown.handle_links', true, &true_or_false)
+option('content_processor.kramdown.ignore_unknown_fragments', false, &true_or_false)
 
 content_processor.register('Maruku')
+
+content_processor.register('Rainpress')
+option('content_processor.rainpress.options', {}, &is_hash)
+
 content_processor.register('RDiscount', :name => 'rdiscount')
 content_processor.register('RDoc', :name => 'rdoc', :ext_map => {'rdoc' => 'html'})
 
 content_processor.register('RedCloth', :name => 'redcloth', :ext_map => {'textile' => 'html'})
-option('content_processor.redcloth.hard_breaks', false,
-       'Specifies whether new lines are turned into hard breaks', &true_or_false)
+option('content_processor.redcloth.hard_breaks', false, &true_or_false)
 
 content_processor.register('Ruby')
 
 content_processor.register('Sass', :ext_map => {'sass' => 'css'})
 content_processor.register('Scss', :ext_map => {'scss' => 'css'})
-option('content_processor.sass.options', {},
-       'Additional Sass options (also used by the scss processor)', &is_hash)
+option('content_processor.sass.options', {}, &symbolic_hash)
 website.ext.sass_load_paths = []
 
 content_processor.register('Tags')
 
 content_processor.register('Tidy')
-option('content_processor.tidy.options', "-raw",
-       "Additional options passed to the tidy command (-q and -f are always used)", &is_string)
+option('content_processor.tidy.options', "-raw", &is_string)
 
 content_processor.register('Tikz', :ext_map => {'tikz' => 'png'})
-option('content_processor.tikz.libraries', [],
-       'An array of additional TikZ library names', &is_array)
-option('content_processor.tikz.opts', '',
-       'A string with global options for the tikzpicture environment', &is_string)
-option('content_processor.tikz.resolution', '72 72',
-       'A string specifying the render and output resolutions, separated by whitespace') do |val|
+option('content_processor.tikz.libraries', [], &is_array)
+option('content_processor.tikz.opts', '', &is_string)
+option('content_processor.tikz.resolution', '72 72',) do |val|
   raise "The value has to be a string in the format 'RENDER_RES OUTPUT_RES'" unless val.kind_of?(String) && val =~ /^\d+\s+\d+$/
   val
 end
-option('content_processor.tikz.transparent', false,
-       'Specifies whether the generated image should be transparent (only if the extension is png)', &true_or_false)
-option('content_processor.tikz.template', '/templates/tikz.template',
-       'Specifies the template with the LaTeX framework that should be used for rendering', &is_string)
+option('content_processor.tikz.transparent', false, &true_or_false)
+option('content_processor.tikz.template', '/templates/tikz.template', &is_string)
 
 content_processor.register('Xmllint')
-option('content_processor.xmllint.options', "--catalogs --noout --valid",
-       'Options passed to the xmllint command', &is_string)
+option('content_processor.xmllint.options', "--catalogs --noout --valid", &is_string)
 
 
 ########################################################################
@@ -131,8 +125,7 @@ website.ext.context_modules = []
 # Everything related to the destination extension
 require 'webgen/destination'
 
-option('destination', [:file_system, 'out'],
-       'The destination extension which is used to output the generated paths.') do |val|
+option('destination', ['file_system', 'out']) do |val|
   raise "The value needs to be an array with at least one value (the destination extension name)" unless val.kind_of?(Array) && val.length >=1
   val
 end
@@ -152,7 +145,7 @@ website.ext.item_tracker = item_tracker = Webgen::ItemTracker.new(website)
 item_tracker.register('NodeContent')
 
 item_tracker.register('NodeMetaInfo')
-website.blackboard.add_listener(:after_node_created) do |node|
+website.blackboard.add_listener(:after_node_created, 'item_tracker.node_meta_info') do |node|
   item_tracker.add(node, :node_meta_info, node)
   item_tracker.add(node, :node_meta_info, node, Webgen::ItemTracker::NodeMetaInfo::CONTENT_MODIFICATION_KEY)
 end
@@ -160,55 +153,63 @@ end
 item_tracker.register('Nodes')
 item_tracker.register('File')
 item_tracker.register('MissingNode')
-website.blackboard.add_listener(:node_resolution_failed) do |path, lang|
-  website.ext.item_tracker.add(website.ext.path_handler.current_dest_node, :missing_node, path, lang)
-  website.logger.error do
-    ["Could not resolve '#{path}' in language '#{lang}' in <#{website.ext.path_handler.current_dest_node}>",
-     "webgen will automatically try to resolve this error by rendering this path again later.",
-     "If the error persists, the content of the path in question needs to be edited to correct the error."]
+website.blackboard.add_listener(:node_resolution_failed, 'item_tracker.missing_node') do |path, lang|
+  if website.ext.path_handler.current_dest_node
+    website.ext.item_tracker.add(website.ext.path_handler.current_dest_node, :missing_node, path, lang)
+    website.logger.error do
+      ["Could not resolve '#{path}' in language '#{lang}' in <#{website.ext.path_handler.current_dest_node}>",
+       "webgen will automatically try to resolve this error by rendering this path again later.",
+       "If the error persists, the content of the path in question needs to be edited to correct the error."]
+    end
   end
 end
 
+item_tracker.register('TemplateChain')
+
 ########################################################################
 # The link definitions extension
 website.ext.link_definitions = {}
 
 
+########################################################################
+# Miscellaneous extensions
+website.ext.misc = OpenStruct.new
+
+require 'webgen/misc/dummy_index'
+website.ext.misc.dummy_index = Webgen::Misc::DummyIndex.new(website)
+option('misc.dummy_index.enabled', true, &true_or_false)
+option('misc.dummy_index.directory_indexes', ['index.html'])
+
+
 ########################################################################
 # Everything related to the node finder extension
 require 'webgen/node_finder'
 
 website.ext.node_finder = Webgen::NodeFinder.new(website)
-option('node_finder.option_sets', {},
-       'Node finder option sets that can be referenced by name')
+option('node_finder.option_sets', {})
 
 
 ########################################################################
 # Everything related to the path handler extension
 require 'webgen/path_handler'
 
-option('path_handler.patterns.case_sensitive', false,
-       'Specifies whether patterns are considered to be case sensitive', &true_or_false)
-option('path_handler.patterns.match_leading_dot', false,
-       'Specifies whether paths parts starting with a dot are matched', &true_or_false)
-option('path_handler.lang_code_in_dest_path', 'except_default',
-       'Specifies whether destination paths should use the language part in their name') do |val|
+option('path_handler.patterns.case_sensitive', false, &true_or_false)
+option('path_handler.patterns.match_leading_dot', false, &true_or_false)
+option('path_handler.lang_code_in_dest_path', 'except_default') do |val|
   if val == true || val == false || val == 'except_default'
     val
   else
     raise "The value has to be 'true', 'false' or 'except_default'"
   end
 end
-option('path_handler.version_in_dest_path', 'except_default',
-       'Specifies whether destination paths should use the version name in their name') do |val|
+option('path_handler.version_in_dest_path', 'except_default') do |val|
   if val == true || val == false || val == 'except_default'
     val
   else
     raise "The value has to be 'true', 'false' or 'except_default'"
   end
 end
-option('path_handler.default_template', 'default.template',
-       'The name of the default template file')
+option('path_handler.default_template', 'default.template')
 
 website.ext.path_handler = path_handler = Webgen::PathHandler.new(website)
 
@@ -234,10 +235,8 @@ sources_validator = lambda do |val|
   val
 end
 
-option('sources', [['/', :file_system, 'src']],
-       'One or more sources from which paths are read', &sources_validator)
-option('sources.ignore_paths', ['**/*~', '**/.svn/**'],
-       'Patterns for paths that should be ignored') do |val|
+option('sources', [['/', :file_system, 'src']], &sources_validator)
+option('sources.ignore_paths', ['**/*~', '**/.svn/**', '**/.gitignore']) do |val|
   raise "The value has to be an array of patterns" unless val.kind_of?(Array) && val.all? {|item| item.kind_of?(String)}
   val
 end
@@ -256,112 +255,80 @@ require 'webgen/tag'
 
 website.ext.tag = tag = Webgen::Tag.new(website)
 
-option('tag.prefix', '',
-       'The prefix used for tag names to avoid name clashes when another content processor uses similar markup.',
-       &is_string)
+option('tag.prefix', '', &is_string)
 
 tag.register('Date')
-option('tag.date.format', '%Y-%m-%d %H:%M:%S',
-       'The format of the date (same options as Ruby\'s Time#strftime)', &is_string)
+option('tag.date.format', '%Y-%m-%d %H:%M:%S', &is_string)
 
 tag.register('MetaInfo', :names => ['meta_info', :default])
-option('tag.meta_info.escape_html', true,
-       'Special HTML characters in the output will be escaped if true', &true_or_false)
-option('tag.meta_info.mi', nil,
-       'The name of the meta information that should be output', &is_string)
+option('tag.meta_info.escape_html', true, &true_or_false)
+option('tag.meta_info.mi', nil, &is_string)
 
 tag.register('Relocatable', :names => ['relocatable', 'r'], :mandatory => ['path'])
-option('tag.relocatable.path', nil,
-       'The path which should be made relocatable', &is_string)
-option('tag.relocatable.ignore_unknown_fragment', false,
-       'Specifies whether an unknown, non-resolvable fragment part should be ignored', &true_or_false)
+option('tag.relocatable.path', nil, &is_string)
+option('tag.relocatable.ignore_unknown_fragment', false, &true_or_false)
 
 tag.register('Link', :mandatory => ['path'])
-option('tag.link.path', nil,
-       'The (A)LCN path to which a link should be generated', &is_string)
-option('tag.link.attr', {},
-       'A hash of additional HTML attributes that should be set on the link', &is_hash)
+option('tag.link.path', nil, &is_string)
+option('tag.link.attr', {}, &is_hash)
 
 tag.register('ExecuteCommand', :mandatory => ['command'])
-option('tag.execute_command.command', nil,
-       'The command which should be executed', &is_string)
-option('tag.execute_command.process_output', true,
-       'The output of the command will be scanned for tags if true', &true_or_false)
-option('tag.execute_command.escape_html', true,
-       'Special HTML characters in the output will be escaped if true', &true_or_false)
+option('tag.execute_command.command', nil, &is_string)
+option('tag.execute_command.process_output', true, &true_or_false)
+option('tag.execute_command.escape_html', true, &true_or_false)
 
 tag.register('IncludeFile', :mandatory => ['filename'])
-option('tag.include_file.filename', nil,
-       'The name of the file which should be included (relative to the website).', &is_string)
-option('tag.include_file.process_output', true,
-       'The file content will be scanned for tags if true.', &true_or_false)
-option('tag.include_file.escape_html', true,
-       'Special HTML characters in the file content will be escaped if true.', &true_or_false)
+option('tag.include_file.filename', nil, &is_string)
+option('tag.include_file.process_output', true, &true_or_false)
+option('tag.include_file.escape_html', true, &true_or_false)
 
 tag.register('Coderay', :mandatory => ['lang'])
-option('tag.coderay.lang', 'ruby',
-       'The language used for highlighting')
-option('tag.coderay.process_body', true,
-       'The tag body will be scanned for tags before highlighting if true', &true_or_false)
-option('tag.coderay.wrap', :div,
-       "Specifies how the code should be wrapped, either 'div' or 'span'") do |val|
+option('tag.coderay.lang', 'ruby')
+option('tag.coderay.process_body', true &true_or_false)
+option('tag.coderay.wrap', 'div') do |val|
   val = val.to_s.intern
   raise "The value has to be either div or span" unless val == :div || val == :span
   val
 end
-option('tag.coderay.css', 'style',
-       'Specifies how the highlighted code should be styled')  do |val|
+option('tag.coderay.css', 'style')  do |val|
   val = val.to_s
   raise "The value has to be class, style or other" unless %w[class style other].include?(val)
   val
 end
-option('tag.coderay.line_numbers', true,
-       'Show line numbers', &true_or_false)
-option('tag.coderay.line_number_start', 1,
-       'Line number of first line', &is_integer)
-option('tag.coderay.bold_every', 10,
-       'The interval at which the line number appears bold', &is_integer)
-option('tag.coderay.tab_width', 8,
-       'Number of spaces used for a tabulator', &is_integer)
+option('tag.coderay.line_numbers', true, &true_or_false)
+option('tag.coderay.line_number_start', 1, &is_integer)
+option('tag.coderay.bold_every', 10, &is_integer)
+option('tag.coderay.tab_width', 8, &is_integer)
 
 tag.register('Tikz', :mandatory => ['path'])
-option('tag.tikz.path', nil,
-       'The path for the created image', &is_string)
-option('tag.tikz.img_attr', {},
-       'A hash of additional HTML attributes for the created img tag', &is_hash)
+option('tag.tikz.path', nil, &is_string)
+option('tag.tikz.img_attr', {}, &is_hash)
 
 tag.register('Langbar')
-option('tag.langbar.show_single_lang', true,
-       'Should the link be shown although the page is only available in one language?', &true_or_false)
-option('tag.langbar.show_own_lang', true,
-       'Should the link to the currently displayed language page be shown?', &true_or_false)
-option('tag.langbar.template', '/templates/tag.template',
-       'The block \'tag.langbar\' in this template file is used for rendering')
-option('tag.langbar.separator', ' | ',
-       'Specifies the string that should be used as separator between the individual language parts.')
+option('tag.langbar.show_single_lang', true, &true_or_false)
+option('tag.langbar.show_own_lang', true, &true_or_false)
+option('tag.langbar.template', '/templates/tag.template')
+option('tag.langbar.separator', ' | ')
 
 tag.register('BreadcrumbTrail')
-option('tag.breadcrumb_trail.omit_dir_index', false,
-       'Omit the last path component if it is an index path', &true_or_false)
-option('tag.breadcrumb_trail.start_level', 0,
-       'The level at which the breadcrumb trail starts (starting at 0)', &is_integer)
-option('tag.breadcrumb_trail.end_level', -1,
-       'The level at which the breadcrumb trail ends (starting at 0)', &is_integer)
-option('tag.breadcrumb_trail.separator', ' / ',
-       'The separator string which appears between the breadcrumb links', &is_string)
-option('tag.breadcrumb_trail.template', '/templates/tag.template',
-       'The block \'tag.breadcrumb_trail\' in this template file is used for rendering')
+option('tag.breadcrumb_trail.omit_dir_index', false &true_or_false)
+option('tag.breadcrumb_trail.start_level', 0, &is_integer)
+option('tag.breadcrumb_trail.end_level', -1, &is_integer)
+option('tag.breadcrumb_trail.separator', ' / ', &is_string)
+option('tag.breadcrumb_trail.template', '/templates/tag.template',)
 
 tag.register('Menu')
-option('tag.menu.style', 'nested',
-       'The menu rendering style to be used, either nested or flat') do |val|
+option('tag.menu.style', 'nested') do |val|
   raise "The value has to be 'nested' or 'flat'" unless %w[nested flat].include?(val.to_s)
   val.to_s
 end
-option('tag.menu.options', {},
-       'Node finder options that specify which nodes the menu should use')
-option('tag.menu.template', '/templates/tag.template',
-       'The block \'tag.menu\' in this template file is used for rendering')
+option('tag.menu.options', {})
+option('tag.menu.template', '/templates/tag.template')
+option('tag.menu.css_class', nil)
+option('tag.menu.item_level_class', 'webgen-menu-level')
+option('tag.menu.item_submenu_class', 'webgen-menu-submenu')
+option('tag.menu.item_submenu_inhierarchy_class', 'webgen-menu-submenu-inhierarchy')
+option('tag.menu.item_selected_class', 'webgen-menu-item-selected')
 
 
 ########################################################################

data/lib/webgen/bundle_loader.rb

@@ -14,10 +14,74 @@ module Webgen
   # 'webgen-BUNDLE_NAME-bundle'.
   class BundleLoader
 
+    # Exposes information about bundles like author, license, bundle homepage as well as extension
+    # and configuration option documentation.
+    class BundleInformation
+
+      def initialize #:nodoc:
+        @bundles = {}
+        @infos = nil
+      end
+
+      # Add the bundle +name+ with the given information file to the list of available bundles.
+      def add_bundle(name, info_file)
+        raise "Bundle information already registered for #{name}" if @bundles.has_key?(name)
+        @bundles[name] = info_file
+        load_bundle_information unless @infos.nil?
+      end
+
+      # Return a hash with information about bundles.
+      def bundles
+        infos[:bundles]
+      end
+
+      # Return a hash with information about extensions.
+      def extensions
+        infos[:extensions]
+      end
+
+      # Return a hash with information about options.
+      def options
+        infos[:options]
+      end
+
+      def infos #:nodoc:
+        load_bundle_information if @infos.nil?
+        @infos
+      end
+      private :infos
+
+      def load_bundle_information #:nodoc:
+        @infos = {:bundles => {}, :extensions => {}, :options => {}}
+
+        @bundles.each do |bundle, info_file|
+          if info_file.nil?
+            @infos[:bundles][bundle] = {}
+          else
+            infos = YAML.load(File.read(info_file))
+            [:extensions, :options].each do |type|
+              if data = infos.delete(type.to_s)
+                data.each do |name, hash|
+                  hash['bundle'] = bundle
+                  hash['author'] ||= infos['author']
+                end
+                @infos[type].update(data)
+              end
+            end
+            @infos[:bundles][bundle] = infos
+          end
+        end
+
+        @infos
+      end
+      private :load_bundle_information
+
+    end
+
     # Create a new BundleLoader object belonging to the website object +website+.
     def initialize(website, ext_dir)
       @website = website
-      @website.ext.bundles = {}
+      @website.ext.bundle_infos = BundleInformation.new
       @ext_dir = ext_dir
       @loaded = []
       @stack = []
@@ -30,18 +94,27 @@ module Webgen
       file = File.expand_path(file)
       return if @loaded.include?(file)
 
-      @loaded.push(file)
-      @stack.push(file)
-      self.instance_eval(File.read(file), file)
-      @stack.pop
+      load!(file)
 
       if file != File.expand_path(File.join(@ext_dir, 'init.rb'))
         name = File.basename(File.dirname(file))
         info_file = File.join(File.dirname(file), 'info.yaml')
-        @website.ext.bundles[name] = (File.file?(info_file) ? info_file : nil)
+        @website.ext.bundle_infos.add_bundle(name, File.file?(info_file) ? info_file : nil)
       end
     end
 
+    # Force-loads the given file and does just that (i.e. no checking if file exists and no bundle
+    # registration).
+    #
+    # **Note**: This method should normally not be called in an extension bundle, use the #load
+    # method instead.
+    def load!(file)
+      @loaded.push(file)
+      @stack.push(file)
+      self.instance_eval(File.read(file), file)
+      @stack.pop
+    end
+
     # Loads all bundles that are marked for auto-loading.
     def load_autoload_bundles
       bundles = Gem::Specification.map {|s| s.name }.uniq.map do |gem_name|
@@ -104,8 +177,8 @@ module Webgen
     # Define a configuration option.
     #
     # See Webgen::Configuration#define_option for more information.
-    def option(name, default, description, &validator)
-      @website.config.define_option(name, default, description, &validator)
+    def option(name, default, &validator)
+      @website.config.define_option(name, default, &validator)
     end
 
     # Return the website object.
@@ -117,7 +190,7 @@ module Webgen
     # source.
     #
     # See Webgen::Source for more information.
-    def mount_passive(dir, mount_point = '/', glob = '**/*')
+    def mount_passive(dir, mount_point = '/', glob = '{*,**/*}')
       @website.ext.source.passive_sources.unshift([mount_point, :file_system, absolute_path(dir), glob])
     end