webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/common/sitemap.rb

@@ -1,83 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/tag'
-require 'webgen/websiteaccess'
-
-module Webgen::Common
-
-  # This class provides functionality for creating sitemaps and checking if a sitemap has changed.
-  class Sitemap
-
-    include Webgen::WebsiteAccess
-
-    def initialize #:nodoc:
-      website.blackboard.add_listener(:node_changed?, method(:node_changed?))
-    end
-
-    # Return the sitemap tree as Webgen::Tag::Menu::MenuNode created for the +node+ in the language
-    # +lang+ using the provided +options+ which can be any configuration option starting with
-    # <tt>common.sitemap</tt>.
-    def create_sitemap(node, lang, options)
-      @options = options
-      tree = recursive_create(nil, node.tree.root, lang).sort!
-      @options = nil
-      (node.node_info[:common_sitemap] ||= {})[[options.to_a.sort, lang]] = tree.to_lcn_list
-      tree
-    end
-
-    #######
-    private
-    #######
-
-    # Recursively create the sitemap.
-    def recursive_create(parent, node, lang, in_sitemap = true)
-      mnode = Webgen::Tag::Menu::MenuNode.new(parent, node)
-      node.children.map do |n|
-        sub_in_sitemap = in_sitemap?(n, lang)
-        [(!n.children.empty? || sub_in_sitemap ? n : nil), sub_in_sitemap]
-      end.each do |n, sub_in_sitemap|
-        next if n.nil?
-        sub_node = recursive_create(mnode, n, lang, sub_in_sitemap)
-        mnode.children << sub_node unless sub_node.nil?
-      end
-      (mnode.children.empty? && !in_sitemap ? nil : mnode)
-    end
-
-    # Return +true+ if the +child+ of the +node+ is in the sitemap for the language +lang+.
-    def in_sitemap?(child, lang, allow_index_file = false)
-      ((option('common.sitemap.used_kinds').empty? || option('common.sitemap.used_kinds').include?(child['kind']) ||
-        (child.routing_node(lang, false) != child && in_sitemap?(child.routing_node(lang), lang, true))) &&
-       (option('common.sitemap.any_lang') || child.lang.nil? || child.lang == lang) &&
-       (!option('common.sitemap.honor_in_menu') || child['in_menu']) &&
-       (allow_index_file || child.parent == child.tree.root || child.parent.routing_node(lang) != child))
-    end
-
-    # Retrieve the configuration option value for +name+. The value is taken from the current
-    # configuration options hash if +name+ is specified there or from the website configuration
-    # otherwise.
-    def option(name)
-      (@options && @options.has_key?(name) ? @options[name] : website.config[name])
-    end
-
-    # Check if the sitemaps for +node+ have changed.
-    def node_changed?(node)
-      return if !node.node_info[:common_sitemap]
-
-      node.node_info[:common_sitemap].each do |(options, lang), cached_tree|
-        @options = options.to_hash
-        tree = recursive_create(nil, node.tree.root, lang).sort!.to_lcn_list
-        @options = nil
-
-        if (tree != cached_tree) ||
-            (tree.flatten.any? do |alcn|
-               (n = node.tree[alcn]) && (r = n.routing_node(lang)) && r.meta_info_changed?
-             end)
-          node.flag(:dirty)
-          break
-        end
-      end
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor.rb

@@ -1,117 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen
-
-  # Namespace for all content processors.
-  #
-  # == Implementing a content processor
-  #
-  # Content processors are used to process the content of files, normally of files in Webgen Page
-  # Format. A content processor only needs to respond to one method called +call+ and must not take
-  # any parameters in the +initialize+ method. This method is invoked with a
-  # Webgen::Context object that provides the whole context (especially the content
-  # and the node chain) and the method needs to return this object. During processing a content
-  # processor normally changes the content of the context but it does not need to.
-  #
-  # A self-written content processor does not need to be in the Webgen::ContentProcessor namespace
-  # but all shipped ones do.
-  #
-  # After writing the content processor class, one needs to add it to the
-  # <tt>contentprocessor.map</tt> hash so that it is used by webgen. The key for the entry needs to
-  # be a short name without special characters or spaces and the value can be:
-  #
-  # * the class name, not as constant but as a string - then this content processor is assumed to
-  #   work with textual data -, or
-  #
-  # * an array with the class name like before and the type, which needs to be <tt>:binary</tt> or
-  #   <tt>:text</tt>.
-  #
-  # == Sample Content Processor
-  #
-  # The following sample content processor checks for a meta information +replace_key+ and replaces
-  # strings of the form <tt>replace_key:path/to/node</tt> with a link to the specified node if it is
-  # found.
-  #
-  # Note how the content node, the reference node and the destination node are used sothat the
-  # correct meta information is used, the node is correctly resolved and the correct relative link
-  # is calculated respectively!
-  #
-  #   class SampleProcessor
-  #
-  #     def call(context)
-  #       if !context.content_node['replace_key'].to_s.empty?
-  #         context.content.gsub!(/#{context.content_node['replace_key']}:([\w\/.]+)/ ) do |match|
-  #           link_node = context.ref_node.resolve($1, context.content_node.lang)
-  #           if link_node
-  #             context.dest_node.link_to(link_node, :lang => context.content_node.lang)
-  #           else
-  #             match
-  #           end
-  #         end
-  #       end
-  #       context
-  #     rescue Exception => e
-  #       raise "Error while replacing special key: #{e.message}"
-  #     end
-  #
-  #   end
-  #
-  #   Webgen::WebsiteAccess.website.config['contentprocessor.map']['replacer'] = 'SampleProcessor'
-  #   # Or one could equally write
-  #   # Webgen::WebsiteAccess.website.config['contentprocessor.map']['replacer'] = ['SampleProcessor', :text]
-  #
-  module ContentProcessor
-
-    autoload :Tags, 'webgen/contentprocessor/tags'
-    autoload :Blocks, 'webgen/contentprocessor/blocks'
-    autoload :Maruku, 'webgen/contentprocessor/maruku'
-    autoload :RedCloth, 'webgen/contentprocessor/redcloth'
-    autoload :Erb, 'webgen/contentprocessor/erb'
-    autoload :Haml, 'webgen/contentprocessor/haml'
-    autoload :Sass, 'webgen/contentprocessor/sass'
-    autoload :Scss, 'webgen/contentprocessor/scss'
-    autoload :RDoc, 'webgen/contentprocessor/rdoc'
-    autoload :Builder, 'webgen/contentprocessor/builder'
-    autoload :Erubis, 'webgen/contentprocessor/erubis'
-    autoload :RDiscount, 'webgen/contentprocessor/rdiscount'
-    autoload :Fragments, 'webgen/contentprocessor/fragments'
-    autoload :Head, 'webgen/contentprocessor/head'
-    autoload :Tidy, 'webgen/contentprocessor/tidy'
-    autoload :Xmllint, 'webgen/contentprocessor/xmllint'
-    autoload :Kramdown, 'webgen/contentprocessor/kramdown'
-    autoload :Less, 'webgen/contentprocessor/less'
-
-    # Return the list of all available content processors.
-    def self.list
-      WebsiteAccess.website.config['contentprocessor.map'].keys
-    end
-
-    # Return the content processor object identified by +name+.
-    def self.for_name(name)
-      klass, cp_type = WebsiteAccess.website.config['contentprocessor.map'][name]
-      klass.nil? ? nil : WebsiteAccess.website.cache.instance(klass)
-    end
-
-    # Return whether the content processor identified by +name+ is processing binary data.
-    def self.is_binary?(name)
-      WebsiteAccess.website.config['contentprocessor.map'][name].kind_of?(Array) &&
-        WebsiteAccess.website.config['contentprocessor.map'][name].last == :binary
-    end
-
-    # Helper class for accessing content processors in a Webgen::Context object.
-    class AccessHash
-
-      # Check if a content processor called +name+ exists.
-      def has_key?(name)
-        Webgen::ContentProcessor.list.include?(name)
-      end
-
-      # Return (and proboably initialize) the content processor called +name+.
-      def [](name)
-        Webgen::ContentProcessor.for_name(name)
-      end
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/blocks.rb

@@ -1,92 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Replaces special xml tags with the rendered content of a node.
-  class Blocks
-
-    include Webgen::Loggable
-
-    BLOCK_RE = /<webgen:block\s*?((?:\s\w+=('|")[^'"]+\2)+)\s*\/>/
-    BLOCK_ATTR_RE = /(\w+)=('|")([^'"]+)\2/
-
-    # Replace the webgen:block xml tags with the rendered content of the specified node.
-    def call(context)
-      context.content.gsub!(BLOCK_RE) do |match|
-        attr = {}
-        match_object = $~
-        attr[:line_nr_proc] = lambda { match_object.pre_match.scan("\n").size + 1 }
-        match.scan(BLOCK_ATTR_RE) {|name, sep, content| attr[name.to_sym] = content}
-        render_block(context, attr)
-      end
-      context
-    end
-
-    # Render a block of a page node and return the result.
-    #
-    # The Webgen::Context object +context+ is used as the render context and the +options+ hash
-    # needs to hold all relevant information, that is:
-    #
-    # [<tt>:name</tt> (mandatory)]
-    #   The name of the block that should be used.
-    # [<tt>:chain</tt>]
-    #   The node chain used for rendering. If this is not specified, the node chain from the context
-    #   is used. It needs to be a String in the format <tt>(A)LCN;(A)LCN;...</tt> or an array of
-    #   nodes.
-    # [<tt>:node</tt>]
-    #   Defines which node in the node chain should be used. Valid values are +next+ (= default
-    #   value; the next node in the node chain), +first+ (the first node in the node chain with a
-    #   block called +name+) or +current+ (the currently rendered node, ignores the +chain+ option).
-    # [<tt>:notfound</tt>]
-    #   If this property is set to +ignore+, a missing block will not raise an error. It is unset by
-    #   default, so missing blocks will raise errors.
-    def render_block(context, options)
-      if options[:chain].nil?
-        used_chain = (context[:chain].length > 1 ? context[:chain][1..-1] : context[:chain]).dup
-      elsif options[:chain].kind_of?(Array)
-        used_chain = options[:chain]
-        dest_node = context.content_node
-      else
-        paths = options[:chain].split(';')
-        used_chain = paths.collect do |path|
-          temp_node = context.ref_node.resolve(path.strip, context.dest_node.lang)
-          if temp_node.nil?
-            raise Webgen::RenderError.new("Could not resolve <#{path.strip}>",
-                                          self.class.name, context.dest_node,
-                                          context.ref_node, (options[:line_nr_proc].call if options[:line_nr_proc]))
-          end
-          temp_node
-        end.compact
-        return '' if used_chain.length != paths.length
-        dest_node = context.content_node
-      end
-
-      if options[:node] == 'first'
-        used_chain.shift while used_chain.length > 0 && !used_chain.first.node_info[:page].blocks.has_key?(options[:name])
-      elsif options[:node] == 'current'
-        used_chain = context[:chain].dup
-      end
-      block_node = used_chain.first
-
-      if !block_node || !block_node.node_info[:page].blocks.has_key?(options[:name])
-        if options[:notfound] == 'ignore'
-          return ''
-        elsif block_node
-          raise Webgen::RenderError.new("No block named '#{options[:name]}' found in <#{block_node}>",
-                                        self.class.name, context.dest_node,
-                                        context.ref_node, (options[:line_nr_proc].call if options[:line_nr_proc]))
-        else
-          raise Webgen::RenderError.new("No node in the render chain has a block named '#{options[:name]}'",
-                                        self.class.name, context.dest_node,
-                                        context.ref_node, (options[:line_nr_proc].call if options[:line_nr_proc]))
-        end
-      end
-
-      context.dest_node.node_info[:used_nodes] << block_node.alcn
-      tmp_context = block_node.node_info[:page].blocks[options[:name]].render(context.clone(:chain => used_chain, :dest_node => dest_node))
-      tmp_context.content
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/builder.rb

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/common'
-
-module Webgen::ContentProcessor
-
-  # Processes content that is valid Ruby to build an XML tree. This is done by using the +builder+
-  # library.
-  class Builder
-
-    # Process the content of +context+ which needs to be valid Ruby code. The special variable +xml+
-    # should be used to construct the XML content.
-    def call(context)
-      require 'builder'
-
-      xml = ::Builder::XmlMarkup.new(:indent => 2)
-      eval(context.content, binding, context.ref_node.alcn)
-      context.content = xml.target!
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('builder', self.class.name, context.dest_node, 'builder')
-    rescue Exception => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node,
-                                    Webgen::Common.error_file(e), Webgen::Common.error_line(e))
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/erb.rb

@@ -1,26 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/common'
-
-module Webgen::ContentProcessor
-
-  # Processes embedded Ruby statements.
-  class Erb
-
-    # Process the Ruby statements embedded in the content of +context+.
-    def call(context)
-      require 'erb'
-      extend(ERB::Util)
-
-      erb = ERB.new(context.content)
-      erb.filename = context.ref_node.alcn
-      context.content = erb.result(binding)
-      context
-    rescue Exception => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node,
-                                    Webgen::Common.error_file(e), Webgen::Common.error_line(e))
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/erubis.rb

@@ -1,39 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/common'
-
-module Webgen::ContentProcessor
-
-  # Processes embedded Ruby statements with the +erubis+ library.
-  class Erubis
-
-    # Process the Ruby statements embedded in the content of +context+.
-    def call(context)
-      require 'erubis'
-      # including Erubis because of problem with resolving Erubis::XmlHelper et al
-      self.class.class_eval "include ::Erubis"
-
-      options = context.website.config['contentprocessor.erubis.options']
-      if context[:block]
-        use_pi = context[:block].options['erubis_use_pi']
-        context[:block].options.select {|k,v| k =~ /^erubis_/}.
-          each {|k,v| options[k.sub(/^erubis_/, '').to_sym] = v }
-      end
-      erubis = if (!use_pi.nil? && use_pi) || (use_pi.nil? && context.website.config['contentprocessor.erubis.use_pi'])
-                    ::Erubis::PI::Eruby.new(context.content, options)
-                  else
-                    ::Erubis::Eruby.new(context.content, options)
-                  end
-      erubis.filename = context.ref_node.alcn
-      context.content = erubis.result(binding)
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('erubis', self.class.name, context.dest_node, 'erubis')
-    rescue Exception => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node,
-                                    Webgen::Common.error_file(e), Webgen::Common.error_line(e))
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/fragments.rb

@@ -1,25 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::ContentProcessor
-
-  # Uses the HTML headers h1, h2, ..., h6 to generate nested fragment nodes.
-  class Fragments
-
-    include Webgen::WebsiteAccess
-
-    # Generate the nested fragment nodes from <tt>context.content</tt> under
-    # <tt>content.content_node</tt> but only if there is no associated <tt>:block</tt> data in
-    # +context+ or the block is named +content+.
-    def call(context)
-      if !context[:block] || context[:block].name == 'content'
-        sections = website.blackboard.invoke(:parse_html_headers, context.content)
-        website.blackboard.invoke(:create_fragment_nodes, sections, context.content_node,
-                                  website.blackboard.invoke(:source_paths)[context.content_node.node_info[:src]],
-                                  context.content_node.meta_info['fragments_in_menu'])
-      end
-      context
-    end
-
-  end
-
-end

data/lib/webgen/contentprocessor/haml.rb

@@ -1,34 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'webgen/common'
-
-module Webgen::ContentProcessor
-
-  # Processes content in Haml markup using the +haml+ library.
-  class Haml
-
-    # Convert the content in +haml+ markup to HTML.
-    def call(context)
-      require 'haml'
-
-      locals = {:context => context}
-      context.content = ::Haml::Engine.new(context.content, :filename => context.ref_node.alcn).
-        render(Object.new, locals)
-      context
-    rescue LoadError
-      raise Webgen::LoadError.new('haml', self.class.name, context.dest_node, 'haml')
-    rescue ::Haml::Error => e
-      line = if e.line
-               e.line + 1
-             else
-               Webgen::Common.error_line(e)
-             end
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node, context.ref_node, line)
-    rescue Exception => e
-      raise Webgen::RenderError.new(e, self.class.name, context.dest_node,
-                                    Webgen::Common.error_file(e), Webgen::Common.error_line(e))
-    end
-
-  end
-
-end