webgen 0.3.8 → 0.4.0

data/lib/webgen/plugins/filehandlers/page.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: page.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: page.rb 546 2006-12-23 10:04:53Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,129 +20,196 @@
 #++
 #
 
-require 'webgen/plugins/filehandlers/filehandler'
+load_plugin 'webgen/plugins/filehandlers/filehandler'
 require 'webgen/listener'
-require 'yaml'
-require 'erb'
+require 'webgen/languages'
+require 'webgen/content'
+require 'webgen/node'
 
 module FileHandlers
 
-  # Super class for all page description files. Provides helper methods so that writing new plugins
-  # for page description files is easy.
-  class PageFileHandler < DefaultFileHandler
+  # File handler plugin for handling page files.
+  #
+  # The following message listening hooks (defined via symbols) are available for this plugin
+  # (see Listener):
+  #
+  # +after_node_rendered+:: called after rendering a node via render_node
+  class PageHandler < DefaultHandler
+
+    # Specialised node for URL fragments.
+    class FragmentNode < Node
+
+      def initialize( parent, path )
+        super
+        self.meta_info['inMenu'] = false
+        self.node_info[:processor] = self
+      end
+
+      # Does not write out anything.
+      def write_node
+        #do nothing
+      end
+
+    end
+
+    # Specialised noed for page files.
+    class PageNode < Node
 
-    class PageNode < Node; end;
+      def initialize( parent, path, pagedata )
+        super( parent, path )
+        @meta_info = pagedata.meta_info
+        @node_info[:pagedata] = pagedata
 
-    summary "Class for processing page files"
-    depends_on 'FileHandler', 'DefaultContentHandler'
-    extension 'page'
+        if pagedata.blocks['content']
+          @node_info[:pagesections] = pagedata.blocks['content'].sections
+          create_fragment_nodes( @node_info[:pagesections] )
+        end
+      end
 
-    add_param 'defaultLangInFilename', false, \
-    'If true, the output files for the default language will have the ' \
-    'language in the file name like all other page files. If false, they won''t.'
+      # Overwritten to also handle matching of the page name and the local page name.
+      def =~( path )
+        md = /^(#{@path}|#{@node_info[:local_pagename]}|#{@node_info[:pagename]})(?=#|$)/ =~ path
+        ( md ? $& : nil )
+      end
 
-    add_param 'outputNameStyle', [:name, ['.', :lang], '.html'], 'Defines how the output name should be built. ' \
-    'The correct name will be used for the :name 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.'
+      #######
+      private
+      #######
 
-    add_param 'validator', nil, 'The validator for checking HTML files on their validness. Set to "" or nil to prevent checking.'
+      def create_fragment_nodes( sections )
+        sections.each do |s|
+          FragmentNode.new( self, '#' + s.id )
+          create_fragment_nodes( s.subsections )
+        end
+      end
 
-    add_param 'defaultPageMetaData', \
-    {'useERB' => true,
-     'blocks' => [{'name'=>'content', 'format'=>'textile'}]
-    },'Specifies the default meta data for page files.'
+    end
 
-    used_meta_info 'title', 'orderInfo', 'lang', 'blocks', 'useERB'
+    EXTENSION = 'page'
 
+    infos( :name => 'File/PageHandler',
+           :author => Webgen::AUTHOR,
+           :summary => "Plugin for processing page files"
+           )
+
+    param 'defaultLangInFilename', false, 'If true, the output files for the default language ' +
+      'will have the language in the file name like all other page files. If false, they won''t.'
+
+    param 'outputNameStyle', [:name, ['.', :lang], '.html'], 'Defines how the output name should ' +
+      'be built. The correct name will be used for the :name 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.'
+
+    param 'validator', nil, 'The validator for checking HTML files on their validness. Set ' +
+      'to an empty string or nil to prevent checking.'
+
+    default_meta_info( 'useERB' => true, 'blocks' => [['content', 'textile']] )
+
+    register_extension EXTENSION
 
     include Listener
 
-    def initialize
-      add_msg_name( :AFTER_CONTENT_RENDERED )
-    end
 
-    def create_node( srcName, parent )
-      create_node_internally( parse_data( File.read( srcName ), srcName ), analyse_file_name( File.basename( srcName ) ), parent )
+    def initialize( plugin_manager )
+      super
+      add_msg_name( :after_node_rendered )
+      @dummy_node = Node.new( nil, 'dummy' )
+      @dummy_node.node_info[:src] = 'dummy'
     end
 
-    def create_node_from_data( data, srcName, parent )
-      create_node_internally( parse_data( data, srcName ), analyse_file_name( File.basename( srcName ) ), parent )
+    def create_node( src_name, parent, meta_info )
+      create_node_from_data( src_name, parent, File.read( src_name ), meta_info )
     end
 
-    def render_node( node, with_template = true, block_name = 'content' )
-      unless node['int:content-formatted']
-        useERB = node['useERB']
-        node['blocks'].each do |blockdata|
-          begin
-            content = ( useERB ? ERB.new( blockdata['data'] ).result( binding ) : blockdata['data'] )
-          rescue Exception => e
-            logger.error { "ERB threw an error while processing an ERB template (<#{node.recursive_value('src')}>, block #{blockdata['name']}): #{e.message}" }
-            content = blockdata['data']
-          end
-          node[blockdata['name']] = Webgen::Plugin['DefaultContentHandler'].get_format( blockdata['format'] ).format_content( content )
-        end
-        node['int:content-formatted'] = true
+    # Same functionality as +create_node+, but uses the given +data+ as content.
+    def create_node_from_data( filename, parent, data, meta_info )
+      begin
+        data = WebPageData.new( data, @plugin_manager['ContentConverter/Default'].registered_handlers,
+                                {'blocks' => meta_info['blocks']} )
+      rescue WebPageDataInvalid => e
+        log(:error) { "Invalid page file <#{filename}>: #{e.message}" }
+        return nil
       end
 
-      if with_template
-        templateNode = Webgen::Plugin['TemplateFileHandler'].get_template_for_node( node )
-        begin
-          outstring = ERB.new( templateNode['content'] ).result( binding )
-        rescue Exception => e
-          logger.error { "ERB threw an error while processing an ERB template (<#{templateNode.recursive_value('src')}>): #{e.message}" }
-          outstring = templateNode['content'].dup
+      data.meta_info.update( meta_info )
+      analysed_name = analyse_file_name( filename, data.meta_info['lang'] )
+
+      data.meta_info['lang'] ||= analysed_name.lang
+      data.meta_info['title'] ||= analysed_name.title
+      data.meta_info['orderInfo'] ||= analysed_name.orderInfo
+
+      pagename = analysed_name.name + '.' + EXTENSION
+      localizedPagename = analysed_name.name + '.' + data.meta_info['lang'] + '.' + EXTENSION
+
+      if node = parent.find {|n| n =~ localizedPagename }
+        log(:warn) do
+          "Two input files in the same language for one page, " + \
+          "using <#{node.node_info[:src]}> instead of <#{filename}>"
         end
       else
-        templateNode = node
-        outstring = node[block_name].to_s.dup
+        path = create_output_name( analysed_name, data.meta_info['outputNameStyle'] || param( 'outputNameStyle' ) )
+        node = PageNode.new( parent, path, data  )
+        node.node_info[:src] = analysed_name.filename
+        node.node_info[:processor] = self
+        node.node_info[:pagename] = pagename
+        node.node_info[:local_pagename] = localizedPagename
       end
 
-      outstring = Webgen::Plugin['Tags'].substitute_tags( outstring, node, templateNode )
-      dispatch_msg( :AFTER_CONTENT_RENDERED, outstring, node )
-      outstring
+      node
     end
 
+    # Renders the block called +block_name+ of the given +node+. If +use_templates+ is +true+, then
+    # the node is rendered in context of its templates.
+    def render_node( node, block_name = 'content', use_templates = true )
+      chain = [@dummy_node]
+      content = "{block: #{block_name}}"
+      chain += @plugin_manager['File/TemplateHandler'].templates_for_node( node ) if use_templates
+      chain << node
+
+      result = @plugin_manager['Core/TagProcessor'].process( content, chain )
+      dispatch_msg( :after_node_rendered, result, node )
+      result
+    end
+
+    # See DefaultFileHandler#write_node.
+    #
+    # After the node has been written it is validated by the validator specified in the param
+    # +validator+.
     def write_node( node )
       outstring = render_node( node )
 
-      File.open( node.recursive_value( 'dest' ), File::CREAT|File::TRUNC|File::RDWR ) do |file|
+      File.open( node.full_path, File::CREAT|File::TRUNC|File::RDWR ) do |file|
         file.write( outstring )
       end
 
-      validator = get_param( 'validator' )
-      unless validator.nil? || validator == ''
-        Webgen::Plugin['DefaultHTMLValidator'].get_validator( validator ).validate_file( node.recursive_value( 'dest' ) )
+      validator = param( 'validator' )
+      validators = @plugin_manager['HtmlValidator/Default'].registered_handlers
+      unless validator.nil? || validator == '' || validators[validator].nil?
+        validators[validator].validate_file( node.full_path )
       end
     end
 
-    # Returns a page node in +dirNode+ which has the name +name+.
-    def get_page_node_by_name( dirNode, name )
-      dirNode.find {|node| node['int:pagename'] == name}
-    end
-
-    # Returns the page node for the given language.
-    def get_node_for_lang( node, lang )
-      dirNode = node.parent
-      pageNode = dirNode.find {|child| child['int:pagename'] == node['int:pagename'] && child['lang'] == lang}
-      if pageNode.nil?
-        self.logger.info { "No page node in language '#{lang}' for page '#{node['title']}' found, trying default language" }
-        pageNode = dirNode.find {|child| child['int:pagename'] == node['int:pagename'] && child['lang'] == Webgen::Plugin['Configuration']['lang']}
-        if pageNode.nil?
-          self.logger.warn do
-            "No page node in default language (#{Webgen::Plugin['Configuration']['lang']}) " + \
-            "for page '#{node['title']}' found, using supplied page node"
-          end
-          pageNode = node
-        end
+    # See DefaultFileHandler#node_for_lang
+    def node_for_lang( node, lang )
+      if node['lang'] == lang
+        node
+      else
+        node.parent.find {|c| c.node_info[:pagename] == node.node_info[:pagename] && c['lang'] == lang}
       end
-      pageNode
     end
 
-    # Get the HTML link for the page +node+.
-    def get_html_link( node, refNode, title = nil )
-      lang_node = get_node_for_lang( node, refNode['lang'] )
-      title ||=  lang_node['title']
-      super( lang_node, refNode, title )
+    # See DefaultFileHandler#link_from.
+    #
+    # The special +attr+ value <code>:resolve_lang_node</code> specifies if the lang node should be
+    # resolved or if the current node should be used.
+    def link_from( node, ref_node, attr = {} )
+      lang_node = (attr[:resolve_lang_node] == false ? node : node_for_lang( node, ref_node['lang'] ) )
+      if lang_node.nil?
+        log(:warn) { "Translation of page node <#{node.parent.full_path + node.node_info[:pagename]}> to language '#{ref_node['lang']}' not found, can't create link"}
+        node['title']
+      else
+        super( lang_node, ref_node, attr )
+      end
     end
 
 
@@ -150,77 +217,24 @@ module FileHandlers
     private
     #######
 
-    def create_node_internally( data, analysed, parent )
-      lang = data['lang'] || analysed.lang
-
-      pagename = analysed.name + '.page'
-      localizedPagename = analysed.name + '.' + lang + '.page'
-
-      if node = parent.find {|node| node['int:pagename'] == pagename && node['lang'] == lang }
-        logger.warn do
-          "Two input files in the same language for one page, " + \
-          "using <#{node.recursive_value( 'src' )}> instead of <#{analysed.srcName}>"
-        end
-      else
-        node = PageNode.new( parent )
-        node.metainfo = data
-        node['lang'] ||= analysed.lang
-        node['title'] ||= analysed.title
-        node['orderInfo'] ||= analysed.orderInfo
-        node['src'] = analysed.srcName
-        node['dest'] = create_output_name( analysed, node['outputNameStyle'] || get_param( 'outputNameStyle' ) )
-        node['int:pagename'] = pagename
-        node['int:local-pagename'] = localizedPagename
-        node['processor'] = self
-      end
-
-      return node
-    end
-
-    def parse_data( data, srcName )
-      options = Marshal.load( Marshal.dump( get_param( 'defaultPageMetaData' ) ) )
-      blocks = data.split( /^---\s*$/ )
-      if blocks.length > 0
-        if blocks[0] == ''
-          begin
-            options.update( YAML::load( blocks[1] ) )
-          rescue ArgumentError => x
-            self.logger.error { "Error parsing options for file <#{srcName}>: #{x.message}" }
-          end
-          blocks[0..1] = []
-        end
-        blocks.each {|b| b.gsub!( /^(\\+)(---\s*)$/ ) {|m| "\\" * ($1.length / 2) + $2 } }
-        options['blocks'].each do |blockdata|
-          if !blockdata.kind_of?( Hash ) || !blockdata['name'] || !blockdata['format']
-            self.logger.error { "Block meta information in <#{srcName}> invalid (#{blockdata.inspect})" }
-            next
-          end
-          self.logger.debug { "Block '#{blockdata['name']}' formatted using '#{blockdata['format']}'" }
-          blockdata['data'] = blocks.shift || ''
-        end
-      end
-      options
-    end
-
-    def analyse_file_name( srcName )
-      matchData = /^(?:(\d+)\.)?([^.]*?)(?:\.(\w\w\w?))?\.(.*)$/.match( srcName )
+    def analyse_file_name( filename, lang = nil )
+      matchData = /^(?:(\d+)\.)?([^.]*?)(?:\.(\w\w\w?))?\.(.*)$/.match( File.basename( filename ) )
       analysed = OpenStruct.new
 
-      self.logger.info { "Using default language for file <#{srcName}>" } if matchData[3].nil?
-      analysed.lang      = matchData[3] || Webgen::Plugin['Configuration']['lang']
-      analysed.srcName   = srcName
-      analysed.useLangPart  = ( !get_param( 'defaultLangInFilename' ) && Webgen::Plugin['Configuration']['lang'] == analysed.lang ? false : true )
+      log(:debug) { "Using default language for file <#{filename}>" } if lang.nil? && matchData[3].nil?
+      analysed.lang      = lang || matchData[3] || param( 'lang', 'Core/Configuration' )
+      analysed.filename  = filename
+      analysed.useLangPart  = ( param( 'defaultLangInFilename' ) || param( 'lang', 'Core/Configuration' ) != analysed.lang )
       analysed.name      = matchData[2]
       analysed.orderInfo = matchData[1].to_i
       analysed.title     = matchData[2].tr('_-', ' ').capitalize
-
-      self.logger.debug { analysed.inspect }
+      log(:debug) { analysed.inspect }
 
       analysed
     end
 
-    def create_output_name( analysed, data, omitLangPart = false )
-      data.collect do |part|
+    def create_output_name( analysed, style, omitLangPart = false )
+      style.collect do |part|
         case part
         when String
           part

data/lib/webgen/plugins/filehandlers/template.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: template.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: template.rb 542 2006-12-19 08:29:39Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,26 +20,45 @@
 #++
 #
 
-require 'webgen/plugins/filehandlers/filehandler'
+load_plugin 'webgen/plugins/filehandlers/page'
 
 module FileHandlers
 
-  # Handles template files. Template files are generic files which specify the layout.
-  class TemplateFileHandler < DefaultFileHandler
+  # Handles template files. Template files are just page files with another extension.
+  class TemplateHandler < DefaultHandler
 
-    summary "Represents the template files for the page generation in the tree"
-    extension 'template'
-    add_param 'defaultTemplate', 'default.template', 'The default file name for the template file.'
-    depends_on 'FileHandler'
+    infos( :name => 'File/TemplateHandler',
+           :author => Webgen::AUTHOR,
+           :summary =>  "Handles the template files"
+           )
 
-    used_meta_info 'template'
+    param 'defaultTemplate', 'default.template', 'The default file name for the template file.'
+
+    register_extension 'template'
+
+
+    def create_node( src_name, parent, meta_info )
+      begin
+        page_meta_info = @plugin_manager['Core/FileHandler'].meta_info_for( @plugin_manager['File/PageHandler'] )
+        data = WebPageData.new( File.read( src_name ), @plugin_manager['ContentConverter/Default'].registered_handlers,
+                                page_meta_info.merge( meta_info ) )
+      rescue WebPageDataInvalid => e
+        log(:error) { "Invalid template file <#{src_name}>: #{e.message}" }
+        return nil
+      end
+
+      if node = parent.find {|n| n =~ src_name }
+        log(:warn) { "Can't create node <#{node.full_path}> as it already exists! Using existing!" }
+      else
+        basename = File.basename( src_name )
+        node = FileHandlers::PageHandler::PageNode.new( parent, basename, data  )
+        node['title'] = 'template'
+        node.node_info[:src] = src_name
+        node.node_info[:processor] = self
+        node.node_info[:pagename] = basename
+        node.node_info[:local_pagename] = basename
+      end
 
-    def create_node( srcName, parent )
-      node = Node.new( parent )
-      node['title'] = 'Template'
-      node['src'] = node['dest'] = File.basename( srcName )
-      node['processor'] = self
-      File.open( srcName ) { |file| node['content'] = file.read }
       node
     end
 
@@ -47,52 +66,46 @@ module FileHandlers
       # do not write anything
     end
 
-    # Return the template for +node+.
-    def get_template_for_node( node )
-      return get_template( node ) || get_default_template( node )
+    # Returns the template chain for +node+.
+    def templates_for_node( node )
+      if node['template'].kind_of?( String )
+        template_node = node.resolve_node( node['template'] )
+        if template_node.nil?
+          log(:warn) { "Specified template '#{node['template']}' for <#{node.node_info[:src]}> not found, using default template!" }
+          template_node = get_default_template( node.parent, param( 'defaultTemplate' ) )
+        end
+        node['template'] = template_node
+      elsif node['template'].kind_of?( Node )
+        template_node = node['template']
+      else
+        log(:info) { "Using default template for <#{node.node_info[:src]}>" }
+        template_node = get_default_template( node.parent, param( 'defaultTemplate' ) )
+        node['template'] = template_node
+      end
+
+      if template_node.nil?
+        []
+      else
+        (template_node == node ? [] : templates_for_node( template_node ) + [template_node])
+      end
     end
 
     #######
     private
     #######
 
-    def get_template( node )
-      if node['template'].kind_of?( String ) && node['template'] != ''
-        templateNode = node.node_for_string( node['template'] )
-        if templateNode.nil?
-          self.logger.warn { "Specified template for file <#{node.recursive_value('src')}> not found, using default template!" }
-        end
-        node['template'] = templateNode unless templateNode.nil?
-        return templateNode
-      end
-    end
-
-    # Return the default template for +node+. If the template node is not found in the directory of
-    # the node, the parent directories are searched.
-    def get_default_template( node )
-      node = node.parent until node['int:directory?']
-      templateNode = node.find { |child| child['src'] == get_param( 'defaultTemplate' ) }
-      if templateNode.nil?
-        if node.parent.nil?
-          self.logger.error { "Template file #{get_param( 'defaultTemplate' )} in root directory not found, creating dummy!" }
-          templateNode = DummyTemplateNode.new( node )
-          node.add_child( templateNode )
+    # Returns the default template of the directory node +dir+. If the template node is not found,
+    # the parent directories are searched.
+    def get_default_template( dir, default_template )
+      template_node = dir.find {|child| child =~ default_template }
+      if template_node.nil?
+        if dir.parent.nil?
+          log(:warn) { "No default template '#{default_template}' in root directory found!" }
         else
-          templateNode = get_default_template( node.parent )
+          template_node = get_default_template( dir.parent, default_template )
         end
       end
-      templateNode
-    end
-
-  end
-
-  class DummyTemplateNode < Node
-
-    def initialize( parent )
-      super( parent )
-      self['src'] = self['dest'] = self['title'] = Webgen::Plugin['TemplateFileHandler']['defaultTemplate']
-      self['processor'] = Webgen::Plugin['TemplateFileHandler']
-      self['content'] = ''
+      template_node
     end
 
   end