webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/contentprocessor/tidy.rb

@@ -1,38 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'tempfile'
-
-module Webgen::ContentProcessor
-
-  # Uses the external +tidy+ program to format the content as valid (X)HTML.
-  class Tidy
-
-    include Webgen::Loggable
-
-    # Process the content of +context+ with the +tidy+ program.
-    def call(context)
-      error_file = Tempfile.new('webgen-tidy')
-      error_file.close
-
-      `tidy -v 2>&1`
-      if $?.exitstatus != 0
-        raise Webgen::CommandNotFoundError.new('tidy', self.class.name, context.dest_node)
-      end
-
-      cmd = "tidy -q -f #{error_file.path} #{context.website.config['contentprocessor.tidy.options']}"
-      result = IO.popen(cmd, 'r+') do |io|
-        io.write(context.content)
-        io.close_write
-        io.read
-      end
-      if $?.exitstatus != 0
-        File.readlines(error_file.path).each do |line|
-          log($?.exitstatus == 1 ? :warn : :error) { "Tidy reported problems for <#{context.dest_node}>: #{line}" }
-        end
-      end
-      context.content = result
-      context
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/xmllint.rb

@@ -1,37 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'tempfile'
-
-module Webgen::ContentProcessor
-
-  # Uses the external +xmllint+ program to check if the content is valid (X)HTML.
-  class Xmllint
-
-    include Webgen::Loggable
-
-    # Checks the content of +context+ with the +xmllint+ program for validness.
-    def call(context)
-      error_file = Tempfile.new('webgen-xmllint')
-      error_file.close
-
-      `xmllint --version 2>&1`
-      if $?.exitstatus != 0
-        raise Webgen::CommandNotFoundError.new('xmllint', self.class.name, context.dest_node)
-      end
-
-      cmd = "xmllint #{context.website.config['contentprocessor.xmllint.options']} - 2>'#{error_file.path}'"
-      result = IO.popen(cmd, 'r+') do |io|
-        io.write(context.content)
-        io.close_write
-        io.read
-      end
-      if $?.exitstatus != 0
-        File.read(error_file.path).scan(/^-:(\d+):(.*?\n)(.*?\n)/).each do |line, error_msg, line_context|
-          log(:warn) { "xmllint reported problems for <#{context.dest_node}:~#{line}>: #{error_msg.strip} (context: #{line_context.strip})" }
-        end
-      end
-      context
-    end
-
-  end
-
-end

data/lib/webgen/context/render.rb

@@ -1,32 +0,0 @@
-module Webgen
-
-  class Context
-
-    # Render the named block and return the result.
-    #
-    # call-seq:
-    #   context.render_block(block_name)<br />
-    #   context.render_block(:name => block_name, :option => value, ...)
-    #
-    # This method uses the functionality of the content processor +blocks+ for doing the actual
-    # work, so you may also want to look at Webgen::ContentProcessor::Blocks#render_block. You can
-    # call this method in two ways:
-    #
-    # [<tt>#render_block(block_name)</tt>]
-    #   Renders the block named +block_name+ of the next node in the current node chain. This is the
-    #   version that most want to use since it is equivalent to the use of <tt><webgen:block
-    #   name="block_name" /></tt>. It is equivalent to <tt>#render_block(:name =>
-    #   block_name)</tt>.
-    #
-    # [<tt>#render_block(opts_hash)</tt>]
-    #   This version allows the same level of control over the output as the blocks content
-    #   processor. For a list of valid options have a look at the documentation of the
-    #   Webgen::ContentProcessor::Blocks#render_block method!
-    def render_block(name_or_hash)
-      name_or_hash = {:name => name_or_hash} if name_or_hash.kind_of?(String)
-      website.cache.instance('Webgen::ContentProcessor::Blocks').render_block(self, name_or_hash)
-    end
-
-  end
-
-end

data/lib/webgen/context/tags.rb

@@ -1,20 +0,0 @@
-module Webgen
-
-  class Context
-
-    # Returns the result of evaluating the webgen tag +name+ with the tag parameters +params+ and
-    # the +body+ in the current context.
-    #
-    # Have a look at Webgen::Tag::Base for more information about webgen tags!
-    #
-    # This method is useful when you want to have the functionality of webgen tags available but you
-    # don't want to use the content processor for them. Or, for example, if the used markup language
-    # uses a similar markup as webgen tags do and therefore you can't use the normal webgen tags
-    # content processor.
-    def tag(name, params = {}, body = '')
-      website.cache.instance('Webgen::ContentProcessor::Tags').process_tag(name, params, body, self)
-    end
-
-  end
-
-end

data/lib/webgen/coreext.rb

@@ -1,13 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-# :stopdoc:
-class Array
-
-  def to_hash
-    h = {}
-    self.each {|k,v| h[k] = v}
-    h
-  end
-
-end
-# :startdoc:

data/lib/webgen/default_config.rb

@@ -1,240 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-website = Webgen::WebsiteAccess.website
-config = website.config
-
-# General configuration parameters
-config.website.cache([:file, 'webgen.cache'], :doc => 'The file name (or String) from/to which the cache is read/written')
-config.website.lang('en', :doc => 'The default language used for the website')
-config.website.link_to_current_page(false, :doc => 'Specifies whether links to the current page should be used')
-
-# All things regarding logging
-config.logger.mask(nil, :doc => 'Only show logging events which match the regexp mask')
-
-
-# All things regarding resources
-config.resources({}, :doc => 'A mapping from resource names to source identifiers')
-
-resources = YAML::load(File.read(File.join(Webgen.data_dir, 'resources.yaml')))
-resources.each do |res_path_template, res_name|
-  Dir.glob(File.join(Webgen.data_dir, res_path_template), File::FNM_CASEFOLD).each do |res_path|
-    substs = Hash.new {|h,k| h[k] = "$" + k }
-    substs.merge!({
-                    'basename' => File.basename(res_path),
-                    'basename_no_ext' => File.basename(res_path, '.*'),
-                    'extname' => File.extname(res_path)[1..-1],
-                    :dirnames => File.dirname(res_path).split(File::SEPARATOR),
-                  })
-    name = res_name.to_s.gsub(/\$\w+/) do |m|
-      if m =~ /^\$dir(\d+)$/
-        substs[:dirnames][-($1.to_i)]
-      else
-        substs[m[1..-1]]
-      end
-    end
-    config['resources'][name] = if File.directory?(res_path)
-                                  ["Webgen::Source::FileSystem", res_path]
-                                else
-                                  ["Webgen::Source::FileSystem", File.dirname(res_path), File.basename(res_path)]
-                                 end
-  end
-end
-
-
-# All things regarding sources
-config.sources [['/', "Webgen::Source::FileSystem", 'src']], :doc => 'One or more sources from which files are read, relative to website directory'
-config.passive_sources([['/', "Webgen::Source::Resource", "webgen-passive-sources"]], :doc => 'One or more sources for delayed node creation on node resolution')
-
-# All things regarding source handler
-config.sourcehandler.patterns({
-                                'Webgen::SourceHandler::Copy' => ['**/*.css', '**/*.js', '**/*.html', '**/*.gif', '**/*.jpg', '**/*.png', '**/*.ico'],
-                                'Webgen::SourceHandler::Directory' => ['**/'],
-                                'Webgen::SourceHandler::Metainfo' => ['**/metainfo', '**/*.metainfo'],
-                                'Webgen::SourceHandler::Template' => ['**/*.template'],
-                                'Webgen::SourceHandler::Page' => ['**/*.page'],
-                                'Webgen::SourceHandler::Virtual' => ['**/virtual', '**/*.virtual'],
-                                'Webgen::SourceHandler::Feed' => ['**/*.feed'],
-                                'Webgen::SourceHandler::Sitemap' => ['**/*.sitemap']
-                              }, :doc => 'Source handler to path pattern map')
-config.sourcehandler.invoke({
-                              1 => ['Webgen::SourceHandler::Directory', 'Webgen::SourceHandler::Metainfo'],
-                              5 => ['Webgen::SourceHandler::Copy', 'Webgen::SourceHandler::Template',
-                                    'Webgen::SourceHandler::Page', 'Webgen::SourceHandler::Feed',
-                                    'Webgen::SourceHandler::Sitemap'],
-                              9 => ['Webgen::SourceHandler::Virtual']
-                            }, :doc => 'All source handlers listed here are used by webgen and invoked according to their priority setting')
-config.sourcehandler.casefold(true, :doc => 'Specifies whether path are considered to be case-sensitive')
-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')
-
-config.sourcehandler.default_meta_info({
-                                         :all => {
-                                           'output_path' => 'standard',
-                                           'output_path_style' => [:parent, :basename, ['.', :lang], :ext]
-                                         },
-                                         'Webgen::SourceHandler::Copy' => {
-                                           'kind' => 'asset'
-                                         },
-                                         'Webgen::SourceHandler::Directory' => {
-                                           'index_path' => 'index.html',
-                                           'kind' => 'directory'
-                                         },
-                                         'Webgen::SourceHandler::Page' => {
-                                           'kind' => 'page',
-                                           'fragments_in_menu' => true,
-                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,markdown,blocks,fragments'}}
-                                         },
-                                         'Webgen::SourceHandler::Fragment' => {
-                                           'kind' => 'fragment'
-                                         },
-                                         'Webgen::SourceHandler::Template' => {
-                                           'blocks' => {'default' => {'pipeline' => 'erb,tags,blocks,head'}}
-                                         },
-                                         'Webgen::SourceHandler::Metainfo' => {
-                                           'blocks' => {1 => {'name' => 'paths'}, 2 => {'name' => 'alcn'}}
-                                         },
-                                         'Webgen::SourceHandler::Feed' => {
-                                           'rss' => true,
-                                           'atom' => true,
-                                           'blocks' => {'default' => {'pipeline' => 'erb'}}
-                                         },
-                                         'Webgen::SourceHandler::Sitemap' => {
-                                           'default_priority' => 0.5,
-                                           'default_change_freq' => 'weekly',
-                                           'common.sitemap.any_lang' => true,
-                                           'blocks' => {'default' => {'pipeline' => 'erb'}}
-                                         }
-                                       }, :doc => "Default meta information for all nodes and for nodes belonging to a specific source handler")
-
-config.sourcehandler.template.default_template('default.template', :doc => 'The name of the default template file of a directory')
-
-website.autoload_service(:templates_for_node, 'Webgen::SourceHandler::Template')
-
-website.autoload_service(:create_fragment_nodes, 'Webgen::SourceHandler::Fragment')
-website.autoload_service(:parse_html_headers, 'Webgen::SourceHandler::Fragment')
-
-
-# All things regarding output
-config.output ["Webgen::Output::FileSystem", 'out'], :doc => 'The class which is used to output the generated paths.'
-config.output.do_deletion(false, :doc => 'Specifies whether the generated output paths should be deleted once the sources are deleted')
-
-
-Webgen::WebsiteAccess.website.blackboard.add_service(:output_instance, Webgen::Output.method(:instance))
-
-
-# All things regarding content processors
-config.contentprocessor.map({
-                              'markdown' => 'Webgen::ContentProcessor::Kramdown',
-                              'maruku' => 'Webgen::ContentProcessor::Maruku',
-                              'textile' => 'Webgen::ContentProcessor::RedCloth',
-                              'redcloth' => 'Webgen::ContentProcessor::RedCloth',
-                              'tags' => 'Webgen::ContentProcessor::Tags',
-                              'blocks' => 'Webgen::ContentProcessor::Blocks',
-                              'erb' => 'Webgen::ContentProcessor::Erb',
-                              'haml' => 'Webgen::ContentProcessor::Haml',
-                              'sass' => 'Webgen::ContentProcessor::Sass',
-                              'scss' => 'Webgen::ContentProcessor::Scss',
-                              'rdoc' => 'Webgen::ContentProcessor::RDoc',
-                              'builder' => 'Webgen::ContentProcessor::Builder',
-                              'erubis' => 'Webgen::ContentProcessor::Erubis',
-                              'rdiscount' => 'Webgen::ContentProcessor::RDiscount',
-                              'fragments' => 'Webgen::ContentProcessor::Fragments',
-                              'head' => 'Webgen::ContentProcessor::Head',
-                              'tidy' => 'Webgen::ContentProcessor::Tidy',
-                              'xmllint' => 'Webgen::ContentProcessor::Xmllint',
-                              'kramdown' => 'Webgen::ContentProcessor::Kramdown',
-                              'less' => 'Webgen::ContentProcessor::Less'
-                            }, :doc => 'Content processor name to class map')
-
-Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_names, Webgen::ContentProcessor.method(:list))
-Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor, Webgen::ContentProcessor.method(:for_name))
-Webgen::WebsiteAccess.website.blackboard.add_service(:content_processor_binary?, Webgen::ContentProcessor.method(:is_binary?))
-
-# All things regarding tags
-config.contentprocessor.tags.prefix('', :doc => 'The prefix used for tag names to avoid name clashes when another content processor uses similar markup.')
-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',
-                                   'sitemap' => 'Webgen::Tag::Sitemap',
-                                   'tikz' => 'Webgen::Tag::TikZ',
-                                   'link' => 'Webgen::Tag::Link',
-                                   :default => 'Webgen::Tag::Metainfo'
-                                 }, :doc => 'Tag processor name to class map')
-
-config.contentprocessor.erubis.use_pi(false, :doc => 'Specifies whether processing instructions should be used')
-config.contentprocessor.erubis.options({}, :doc => 'A hash of additional options')
-
-config.contentprocessor.redcloth.hard_breaks(false, :doc => 'Specifies whether new lines are turned into hard breaks')
-
-config.contentprocessor.tidy.options("-raw", :doc => "The options passed to the tidy command")
-
-config.contentprocessor.xmllint.options("--catalogs --noout --valid", :doc => 'Options passed to the xmllint command')
-
-config.contentprocessor.kramdown.options({:auto_ids => true}, :doc => 'The options hash for the kramdown processor')
-config.contentprocessor.kramdown.handle_links(true, :doc => 'Whether all links in a kramdown document should be handled by webgen')
-
-
-config.tag.metainfo.escape_html(true, :doc => 'Special HTML characters in the output will be escaped if true')
-
-config.tag.relocatable.path(nil, :doc => 'The path which should be made relocatable', :mandatory => 'default')
-
-config.tag.menu.start_level(1, :doc => 'The level at which the menu starts.')
-config.tag.menu.min_levels(1, :doc => 'The minimum number of menu levels that should always be shown.')
-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.menu.nested(true, :doc => 'Specifies whether a nested menu list should be generated.')
-
-config.tag.breadcrumbtrail.separator(' / ', :doc => 'Separates the hierachy entries from each other.')
-config.tag.breadcrumbtrail.omit_index_path(false, :doc => 'Omits the last path component if it is an index path.')
-config.tag.breadcrumbtrail.start_level(0, :doc => 'The level at which the breadcrumb trail starts.')
-config.tag.breadcrumbtrail.end_level(-1, :doc => 'The level at which the breadcrumb trail ends.')
-
-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.langbar.lang_names({}, :doc => 'A map from language code to language names')
-config.tag.langbar.process_output(false, :doc => 'The content of the language bar will be scanned for tags if true.')
-
-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.coderay.css(:style, :doc => 'Specifies how the highlighted code should be styled')
-
-config.tag.date.format('%Y-%m-%d %H:%M:%S', :doc => 'The format of the date (same options as Ruby\'s Time#strftime)')
-
-config.tag.tikz.path(nil, :doc => 'The source path of the created image', :mandatory => 'default')
-config.tag.tikz.libraries(nil, :doc => 'An array of additional TikZ library names')
-config.tag.tikz.opts(nil, :doc => 'A string with global options for the tikzpicture environment')
-config.tag.tikz.resolution('72 72', :doc => 'A string specifying the render and output resolutions')
-config.tag.tikz.transparent(false, :doc => 'Specifies whether the generated image should be transparent (only png)')
-config.tag.tikz.img_attr({}, :doc => 'A hash of additional HTML attributes for the created img tag')
-
-config.tag.link.path(nil, :doc => 'The (A)LCN path to which a link should be generated', :mandatory => 'default')
-config.tag.link.attr({}, :doc => 'A hash of additional HTML attributes that should be set on the link')
-
-# All things regarding common functionality
-website.autoload_service(:create_sitemap, 'Webgen::Common::Sitemap')
-
-config.common.sitemap.honor_in_menu(false, :doc => 'Only include pages that are also in the menu if true')
-config.common.sitemap.any_lang(false, :doc => 'Use nodes in any language if true')
-config.common.sitemap.used_kinds(['page'], :doc => 'Array of node kinds that is used for the sitemap')

data/lib/webgen/loggable.rb

@@ -1,25 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/websiteaccess'
-
-module Webgen
-
-  # This module should be included in all classes that need a logging facility.
-  module Loggable
-
-    # Log the result of the +block+ using the log level +log_level+.
-    def log(sev_level, &block)
-      source = (self.kind_of?(Class) ? self.name : self.class.name) + '#' + caller[0][%r"`.*"][1..-2]
-      if WebsiteAccess.website && WebsiteAccess.website.logger && (!WebsiteAccess.website.config['logger.mask'] || source =~ WebsiteAccess.website.config['logger.mask'])
-        WebsiteAccess.website.logger.send(sev_level, source, &block)
-      end
-    end
-
-    # Shortcut for writing a line to the normal log output.
-    def puts(*args)
-      (args.last == :verbose ? log(:verbose) { args[0..-2].join } : log(:stdout) { args.join })
-    end
-
-  end
-
-end

data/lib/webgen/output.rb

@@ -1,86 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/common'
-
-module Webgen
-
-  # Namespace for all classes that know how to write out node content.
-  #
-  # == Implementing an output class
-  #
-  # Output classes know how to write rendered node data to an output location.
-  #
-  # An output class must respond to three methods
-  #
-  # [<tt>exists?(path)</tt>]
-  #   Return +true+ if the output path exists.
-  # [<tt>delete(path)</tt>]
-  #   Delete the given output path.
-  # [<tt>write(path, data, type)</tt>]
-  #   Write the +data+ to the given output +path+. The parameter +data+ is either a String with the
-  #   content or a Webgen::Path::SourceIO object. The parameter +type+ specifies the type of the to
-  #   be written path: <tt>:file</tt> or <tt>:directory</tt>.
-  # [<tt>read(path, mode = 'rb')</tt>]
-  #   Return the content of the given path if it exists or raise an error otherwise. The parameter
-  #   +mode+ specifies the mode in which the path should be opened and defaults to reading in binary
-  #   mode.
-  #
-  #   It seems a bit odd that an output instance has to implement reading functionality. However,
-  #   consider the case where you want webgen to render a website programmatically and *use* the
-  #   output. In this case you need a way to get to content of the written files! This functionality
-  #   is used, for example, in the webgui.
-  #
-  # == Sample Output Class
-  #
-  # Following is a simple but actually used (by the webgui) output class which stores the written
-  # nodes in a hash in memory:
-  #
-  #   class MemoryOutput
-  #     include Webgen::WebsiteAccess
-  #
-  #     attr_reader :data
-  #
-  #     def initialize
-  #       @data = {}
-  #     end
-  #
-  #     def exists?(path)
-  #       @data.has_key?(path)
-  #     end
-  #
-  #     def delete(path)
-  #       @data.delete(path)
-  #     end
-  #
-  #     def write(path, io, type = :file)
-  #       @data[path] = [(io.kind_of?(String) ? io : io.data), type]
-  #     end
-  #
-  #     def read(path, mode = 'rb')
-  #       path = File.join('/', path)
-  #       raise "No such file #{path}" unless @data[path] && @data[path].last == :file
-  #       @data[path].first
-  #     end
-  #   end
-  #
-  #   WebsiteAccess.website.config.output(['MemoryOutput'])
-  #
-  # The last line is used to tell webgen to use this new output class instead of the default one.
-  #
-  module Output
-
-    autoload :FileSystem, 'webgen/output/filesystem'
-
-    # Returns an instance of the configured output class.
-    def self.instance
-      classes = (WebsiteAccess.website.cache.volatile[:classes] ||= {})
-      unless classes.has_key?(:output_instance)
-        klass, *args = WebsiteAccess.website.config['output']
-        classes[:output_instance] = Common.const_for_name(klass).new(*args)
-      end
-      classes[:output_instance]
-    end
-
-  end
-
-end