webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/sourcehandler/fragment.rb

@@ -1,70 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::SourceHandler
-
-  # Handles page fragment nodes and provides utility methods for parsing HTML headers and generating
-  # fragment nodes from them.
-  class Fragment
-
-    include Base
-    include Webgen::WebsiteAccess
-
-    HTML_HEADER_REGEXP = /<h([123456])(?:>|\s([^>]*)>)(.*?)<\/h\1\s*>/i
-    HTML_ATTR_REGEXP = /\s*(\w+)\s*=\s*('|")(.+?)\2\s*/
-
-    # Parse the string +content+ for headers +h1+, ..., +h6+ and return the found, nested sections.
-    #
-    # Only those headers are used which have an +id+ attribute set. The method returns a list of
-    # arrays with entries <tt>level, id, title, sub sections</tt> where <tt>sub sections</tt> is
-    # such a list again.
-    def parse_html_headers(content)
-      sections = []
-      stack = []
-      content.scan(HTML_HEADER_REGEXP).each do |level,attrs,title|
-        next if attrs.nil?
-        id_attr = attrs.scan(HTML_ATTR_REGEXP).find {|name,sep,value| name == 'id'}
-        next if id_attr.nil?
-        id = id_attr[2]
-
-        section = [level.to_i, id, title, []]
-        success = false
-        while !success
-          if stack.empty?
-            sections << section
-            stack << section
-            success = true
-          elsif stack.last.first < section.first
-            stack.last.last << section
-            stack << section
-            success = true
-          else
-            stack.pop
-          end
-        end
-      end
-      sections
-    end
-
-    # Create nested fragment nodes under +parent+ from +sections+ (which can be created using
-    # +parse_html_headers+). +path+ is the source path that defines the fragments (which is not the
-    # same as the creation path for +parent+). The meta information +in_menu+ of the fragment nodes
-    # is set to the parameter +in_menu+ and the meta info +sort_info+ is calculated from the base
-    # +si+ value.
-    def create_fragment_nodes(sections, parent, path, in_menu, si = 1000)
-      sections.each do |level, id, title, sub_sections|
-        fragment_path = parent.alcn.sub(/#.*$/, '') + '#' + id
-        node = website.blackboard.invoke(:create_nodes,
-                                         Webgen::Path.new(fragment_path, path.source_path),
-                                         self) do |cn_path|
-          cn_path.meta_info['title'] = title
-          cn_path.meta_info['in_menu'] = in_menu
-          cn_path.meta_info['sort_info'] = si = si.succ
-          create_node(cn_path, :parent => parent)
-        end.first
-        create_fragment_nodes(sub_sections, node, path, in_menu, si.succ)
-      end
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler/memory.rb

@@ -1,42 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::SourceHandler
-
-  # This source handler should be used for handling nodes that are created during the write
-  # phase.
-  class Memory
-
-    include Webgen::WebsiteAccess
-    include Base
-
-    def initialize #:nodoc:
-      website.blackboard.add_listener(:node_flagged) do |node, *flags|
-        node.tree[node.node_info[:memory_source_alcn]].flag(:dirty) if node.node_info[:memory_source_alcn]
-      end
-    end
-
-    # Create a node for the +path+. The +source_alcn+ specifies the node that creates this memory
-    # node when written. You have two options for providing the content for this node: either you
-    # set +data+ to a string (or a Webgen::Path::SourceIO object) or you provide a block which takes
-    # the created node as argument and returns a string (or a Webgen::Path::SourceIO object).
-    def create_node(path, source_alcn, data = nil)
-      super(path) do |node|
-        node.node_info[:memory_source_alcn] = source_alcn
-        (@data ||= {})[node.alcn] = lambda { data || yield(node) }
-      end
-    end
-
-    # Return the content of the memory +node+. If the memory node was not created in this webgen
-    # run, it will be flagged for reinitialization (and therefore recreation).
-    def content(node)
-      if @data && @data[node.alcn]
-        @data[node.alcn].call
-      else
-        node.flag(:reinit)
-        nil
-      end
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler/metainfo.rb

@@ -1,128 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'pathname'
-require 'yaml'
-
-module Webgen::SourceHandler
-
-  # Handles meta information files which provide meta information for other files.
-  class Metainfo
-
-    include Base
-    include Webgen::WebsiteAccess
-
-    CKEY = [:metainfo, :nodes]
-
-    # Upon creation the object registers itself as listener for some node hooks.
-    def initialize
-      website.blackboard.add_listener(:node_meta_info_changed?, method(:node_meta_info_changed?))
-      website.blackboard.add_listener(:before_node_created, method(:before_node_created))
-      website.blackboard.add_listener(:before_node_deleted, method(:before_node_deleted))
-      website.blackboard.add_listener(:after_node_created, method(:after_node_created))
-      self.nodes ||= []
-    end
-
-    # Create a meta info node from +path+.
-    def create_node(path)
-      page = page_from_path(path)
-      super(path) do |node|
-        [[:mi_paths, 'paths'], [:mi_alcn, 'alcn']].each do |mi_key, block_name|
-          node.node_info[mi_key] = {}
-          if page.blocks.has_key?(block_name) && (data = YAML::load(page.blocks[block_name].content))
-            data.each do |key, value|
-              key = Webgen::Path.make_absolute(path.parent_path, key)
-              node.node_info[mi_key][key] = value
-            end
-          end
-        end
-
-        mark_all_matched_dirty(node, :no_old_data)
-
-        website.cache.permanent[[:sh_metainfo_node_mi, node.alcn]] = {
-          :mi_paths => node.node_info[:mi_paths],
-          :mi_alcn => node.node_info[:mi_alcn]
-        }
-
-        self.nodes << node unless self.nodes.include?(node)
-        self.nodes = self.nodes.sort_by {|n| n.alcn}
-      end
-    end
-
-    def nodes #:nodoc:
-      website.cache.permanent[CKEY]
-    end
-
-    def nodes=(val) #:nodoc:
-      website.cache.permanent[CKEY] = val
-    end
-
-    #######
-    private
-    #######
-
-    # Return +true+ if any meta information for +node+ provided by +mi_node+ has changed.
-    def meta_info_changed?(mi_node, node, option = nil)
-      cached = website.cache.permanent[[:sh_metainfo_node_mi, mi_node.alcn]]
-      (mi_node.node_info[:mi_paths].any? do |pattern, mi|
-         Webgen::Path.match(node.node_info[:creation_path], pattern) &&
-           (option == :force || (!cached && option == :no_old_data) || mi != cached[:mi_paths][pattern])
-       end || mi_node.node_info[:mi_alcn].any? do |pattern, mi|
-         node =~ pattern && (option == :force || (!cached && option == :no_old_data) || mi != cached[:mi_alcn][pattern])
-       end || (option == :no_old_data && cached &&
-               ((cached[:mi_paths].keys - mi_node.node_info[:mi_paths].keys).any? do |p|
-                 Webgen::Path.match(node.node_info[:creation_path], p)
-                end || (cached[:mi_alcn].keys - mi_node.node_info[:mi_alcn].keys).any? do |p|
-                  node =~ p
-                end)
-               )
-       )
-    end
-
-    # Mark all nodes that are matched by a path or an alcn specifcation in the meta info node +node+
-    # as dirty.
-    def mark_all_matched_dirty(node, option = nil)
-      node.tree.node_access[:alcn].each do |path, n|
-        n.flag(:dirty_meta_info) if meta_info_changed?(node, n, option)
-      end
-    end
-
-    # Update the meta info of matched path before a node is created.
-    def before_node_created(path)
-      self.nodes.each do |node|
-        node.node_info[:mi_paths].each do |pattern, mi|
-          path.meta_info.update(mi) if Webgen::Path.match(path, pattern)
-        end
-      end
-    end
-
-    # Update the meta information of a matched alcn after the node has been created.
-    def after_node_created(node)
-      self.nodes.each do |n|
-        n.node_info[:mi_alcn].each do |pattern, mi|
-          node.meta_info.update(mi) if node =~ pattern
-        end
-      end
-    end
-
-    # Check if the +node+ has meta information from any meta info node and if so, if the meta info
-    # node in question has changed.
-    def node_meta_info_changed?(node)
-      self.nodes.each do |n|
-        if n.flagged?(:created) && meta_info_changed?(n, node)
-          node.flag(:dirty_meta_info)
-          return
-        end
-      end
-    end
-
-    # Delete the meta info node +node+ from the internal array.
-    def before_node_deleted(node)
-      return unless node.node_info[:processor] == self.class.name
-      mark_all_matched_dirty(node, :force)
-      website.cache.permanent.delete([:sh_metainfo_node_mi, node.alcn])
-      self.nodes.delete(node)
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler/page.rb

@@ -1,64 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::SourceHandler
-
-  # Source handler for handling content files in Webgen Page Format.
-  class Page
-
-    include Webgen::WebsiteAccess
-    include Base
-
-    def initialize #:nodoc:
-      website.blackboard.add_listener(:node_meta_info_changed?, method(:meta_info_changed?))
-    end
-
-    # Create a page file from +path+.
-    def create_node(path)
-      page = page_from_path(path)
-      path.meta_info['lang'] ||= website.config['website.lang']
-      path.ext = 'html' if path.ext == 'page'
-
-      super(path) do |node|
-        node.node_info[:sh_page_node_mi] = Webgen::Page.meta_info_from_data(path.io.data)
-        node.node_info[:page] = page
-      end
-    end
-
-    # Render the block called +block_name+ of the given +node+. The parameter +templates+ is set to
-    # the default template chain for the given +node+ but you can assign a custom template chain (an
-    # array of template nodes) if need arises. Return +nil+ if an error occurred.
-    def render_node(node, block_name = 'content', templates = website.blackboard.invoke(:templates_for_node, node))
-      chain = [templates, node].flatten
-
-      if chain.first.node_info[:page].blocks.has_key?(block_name)
-        node.node_info[:used_nodes] << chain.first.alcn
-        context = chain.first.node_info[:page].blocks[block_name].render(Webgen::Context.new(:chain => chain))
-        context.content
-      else
-        raise Webgen::RenderError.new("No block named '#{block_name}'",
-                                      self.class.name, node, chain.first)
-      end
-    end
-    alias_method :content, :render_node
-
-    #######
-    private
-    #######
-
-    # Checks if the meta information provided by the file in Webgen Page Format changed.
-    def meta_info_changed?(node)
-      path = website.blackboard.invoke(:source_paths)[node.node_info[:src]]
-      return if node.node_info[:processor] != self.class.name || (path && !path.changed?)
-
-      if !path
-        node.flag(:dirty_meta_info)
-      else
-        old_mi = node.node_info[:sh_page_node_mi]
-        new_mi = Webgen::Page.meta_info_from_data(path.io.data)
-        node.flag(:dirty_meta_info) if old_mi && old_mi != new_mi
-      end
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler/sitemap.rb

@@ -1,60 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'uri'
-require 'time'
-
-module Webgen::SourceHandler
-
-  # Source handler for creating an XML sitemap based on the specification of http://sitemaps.org.
-  #
-  # Uses Webgen::Common::Sitemap to generate the needed sitemap tree and to check if a sitemap has
-  # changed.
-  class Sitemap
-
-    include Webgen::WebsiteAccess
-    include Base
-
-    # Create an XML sitemap from +path+.
-    def create_node(path)
-      page = page_from_path(path)
-      path.ext = 'xml'
-      if path.meta_info['site_url'].nil?
-        raise Webgen::NodeCreationError.new("Needed information site_url is missing",
-                                            self.class.name, path)
-      end
-
-      super(path) do |node|
-        node.node_info[:sitemap] = page
-      end
-    end
-
-    # Return the rendered feed represented by +node+.
-    def content(node)
-      if node.node_info[:sitemap].blocks.has_key?('template')
-        node.node_info[:sitemap].blocks['template'].render(Webgen::Context.new(:chain => [node])).content
-      else
-        chain = [node.resolve("/templates/sitemap.template"), node]
-        node.node_info[:used_nodes] << chain.first.alcn
-        chain.first.node_info[:page].blocks['content'].render(Webgen::Context.new(:chain => chain)).content
-      end
-    end
-
-    # Return the alcns of the sitemap +node+ as a flat list.
-    def alcns(node)
-      website.blackboard.invoke(:create_sitemap, node, node.lang, options_for_node(node)).to_lcn_list.flatten
-    end
-
-    #######
-    private
-    #######
-
-    # Return a hash with the sitemap-creation-options set on the +node+.
-    def options_for_node(node)
-      options = {}
-      node.meta_info.each {|k,v| options[k] = v if k =~ /\./}
-      options
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler/template.rb

@@ -1,66 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Webgen::SourceHandler
-
-  # Source handler for handling template files in Webgen Page Format.
-  class Template
-
-    include Webgen::WebsiteAccess
-    include Webgen::Loggable
-    include Base
-
-    # Create a template node for +path+.
-    def create_node(path)
-      page = page_from_path(path)
-      super(path) do |node|
-        node.node_info[:page] = page
-      end
-    end
-
-    # Return the template chain for +node+.
-    def templates_for_node(node, lang = node.lang)
-      cached_template = (website.cache.volatile[[node.alcn, :templates]] ||= {})
-      if cached_template[lang]
-        template_node = cached_template[lang]
-      elsif node['template'].kind_of?(String)
-        template_node = node.resolve(node['template'], lang)
-        if template_node.nil?
-          log(:warn) { "Specified template '#{node['template']}' for <#{node}> not found, using default template!" }
-          template_node = default_template(node.parent, lang)
-        end
-        cached_template[lang] = template_node
-      elsif node.meta_info.has_key?('template') && node['template'].nil?
-        template_node = cached_template[lang] = nil
-      else
-        log(:info) { "Using default template in language '#{lang}' for <#{node}>" }
-        template_node = default_template(node.parent, lang)
-        if template_node == node && !node.parent.is_root?
-          template_node = default_template(node.parent.parent, lang)
-        end
-        cached_template[lang] = template_node
-      end
-
-      if template_node.nil?
-        []
-      else
-        (template_node == node ? [] : templates_for_node(template_node, lang) + [template_node])
-      end
-    end
-
-    # Return the default template for the directory node +dir+. If the template node is not found,
-    # the parent directories are searched.
-    def default_template(dir_node, lang)
-      template_node = dir_node.resolve(website.config['sourcehandler.template.default_template'], lang)
-      if template_node.nil?
-        if dir_node.is_root?
-          log(:warn) { "No default template in root directory found!" }
-        else
-          template_node = default_template(dir_node.parent, lang)
-        end
-      end
-      template_node
-    end
-
-  end
-
-end

data/lib/webgen/sourcehandler/virtual.rb

@@ -1,117 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'uri'
-require 'yaml'
-
-module Webgen::SourceHandler
-
-  # Handles files which contain specifications for "virtual" nodes, ie. nodes that don't have real
-  # source path.
-  #
-  # This can be used, for example, to provide multiple links to the same node.
-  class Virtual
-
-    include Base
-    include Webgen::WebsiteAccess
-
-    def initialize # :nodoc:
-      website.blackboard.add_listener(:node_meta_info_changed?, method(:node_meta_info_changed?))
-      @path_data = {}
-    end
-
-    # Create all virtual nodes which are specified in +path+.
-    def create_node(path)
-      nodes = []
-      read_data(path).each do |key, meta_info|
-        cache_data = [key, meta_info.dup]
-
-        key = Webgen::Path.make_absolute(path.parent_path, key) + (key =~ /\/$/ ? '/' : '')
-        temp_parent = create_directories(File.dirname(key), path)
-
-        output_path = meta_info.delete('url') || key
-        output_path = (URI::parse(output_path).absolute? || output_path =~ /^\// ?
-                       output_path : File.join(temp_parent.alcn, output_path))
-
-        if key =~ /\/$/
-          nodes << create_directory(key, path, meta_info)
-        else
-          nodes += website.blackboard.invoke(:create_nodes, Webgen::Path.new(key, path.source_path), self) do |cn_path|
-            cn_path.meta_info.update(meta_info)
-            super(cn_path, :output_path => output_path) do |n|
-              n.node_info[:sh_virtual_cache_data] = cache_data
-            end
-          end
-        end
-      end
-      nodes.compact
-    end
-
-    #######
-    private
-    #######
-
-    # Read the entries from the virtual file +data+ and yield the path, and the meta info hash for
-    # each entry. The +parent+ parameter is used for making absolute path values if relative ones
-    # are given.
-    def read_data(path)
-      if !@path_data.has_key?(path) || path.changed?
-        page = page_from_path(path)
-        @path_data[path] = YAML::load(page.blocks['content'].content).collect do |key, meta_info|
-          meta_info ||= {}
-          meta_info['modified_at'] = path.meta_info['modified_at']
-          meta_info['no_output'] = true
-          [key, meta_info]
-        end if page.blocks.has_key?('content')
-        @path_data[path] ||= []
-      end
-      @path_data[path]
-    end
-
-    # Create the needed parent directories for a virtual node.
-    def create_directories(dirname, path)
-      parent = website.tree.root
-      dirname.sub(/^\//, '').split('/').inject('/') do |parent_path, dir|
-        parent_path = File.join(parent_path, dir)
-        parent = create_directory(parent_path, path)
-        parent_path
-      end
-      parent
-    end
-
-    # Create a virtual directory if it does not already exist.
-    def create_directory(dir, path, meta_info = nil)
-      dir_handler = website.cache.instance('Webgen::SourceHandler::Directory')
-      parent = website.tree.root
-      website.blackboard.invoke(:create_nodes,
-                                Webgen::Path.new(File.join(dir, '/'), path.source_path),
-                                dir_handler) do |temp_path|
-        parent = dir_handler.node_exists?(temp_path)
-        if (parent && (parent.node_info[:src] == path.source_path) && !meta_info.nil?) ||
-            !parent
-          temp_path.meta_info.update(meta_info) if meta_info
-          parent.flag(:reinit) if parent
-          parent = dir_handler.create_node(temp_path)
-        end
-        parent
-      end
-      parent
-    end
-
-    # Check if the +node+ is virtual and if, if its meta information has changed. This can only be
-    # the case if the node has been recreated in this run.
-    def node_meta_info_changed?(node)
-      path = website.blackboard.invoke(:source_paths)[node.node_info[:src]]
-      return if node.node_info[:processor] != self.class.name || (path && !path.changed?)
-
-      if !path
-        node.flag(:dirty_meta_info)
-      else
-        old_data = node.node_info[:sh_virtual_cache_data]
-        new_data = read_data(path).find {|key, mi| key == old_data.first}
-        node.flag(:dirty_meta_info) if !new_data || old_data.last != new_data.last
-      end
-    end
-
-  end
-
-end