xmlresume2x 0.2.0

data/doc/src/metainfo.backing

@@ -0,0 +1,37 @@
+index.html:
+  en:
+    title: Home
+    inMenu: true
+    directoryName: XMLResume2x
+    menuOrder: 1
+
+download.html:
+  en:
+    title: Download & Installation
+    inMenu: true
+    menuOrder: 3
+
+features.html:
+  en:
+    title: Features
+    inMenu: true
+    menuOrder: 5
+
+manual.html:
+  en:
+    title: Manual
+    inMenu: true
+    menuOrder: 6
+
+examples.html:
+  en:
+    title: Examples
+    inMenu: true
+    menuOrder: 7
+
+api.html:
+  en:
+    dest: rdoc/index.html
+    title: API Reference
+    menuOrder: 8
+    inMenu: true

data/install.rb

@@ -0,0 +1,24 @@
+
+require 'rpa/install'
+
+class Install_xmlresume2x < RPA::Install::FullInstaller
+  name 'xmlresume2x'
+  version '0.2.0-1'
+  classification Application
+  build do
+    installdocs %w[COPYING ChangeLog TODO]
+    installdocs 'docs'
+    installrdoc %w[README] + Dir['lib/**/*.rb']
+    installdata
+  end
+  description <<-EOF
+Converts an xml resume to various output formats
+
+xmlresume2x can convert CVs written in the XML Resume
+Library format (http://xmlresume.sourceforge.net) to a number
+of formats, including LaTeX markup which uses the europecv
+(http://www.ctan.org/tex-archive/help/Catalogue/entries/europecv.html)
+class which is based on the 'standard' European Curriculum Vitae
+format at http://www.cedefop.eu.int/transparency/cv.asp.
+  EOF
+end

data/lib/xmlresume2x/converter.rb

@@ -0,0 +1,86 @@
+#
+# $Id: converter.rb 23 2004-12-20 11:08:39Z thomas $
+#
+#--
+#
+# xmlresume2x: converts an xml resume to various output formats
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'rbconfig'
+require 'erb'
+require 'rexml/document'
+require 'xmlresume2x/processor'
+
+module XMLResume2x
+
+  VERSION = [0, 2, 0]
+
+  class Converter
+
+    CONFIG_EXT = '.cfg'
+
+    attr_accessor :data_dir
+
+    def initialize
+      @data_dir = File.join( Config::CONFIG["datadir"], "xmlresume2x" )
+      if defined? Gem::Cache
+        gem = Gem::Cache.from_installed_gems.search( "xmlresume2x", "=#{VERSION.join('.')}" ).last
+        @data_dir = File.join( gem.full_gem_path, "data", "xmlresume2x" ) if gem
+      end
+    end
+
+    def available_formats
+      dir_list( format_dir )
+    end
+
+    def available_langs
+      dir_list( lang_dir )
+    end
+
+    def load_config( format, lang, userconfig = nil )
+      @processor = ResumeProcessor.new( lang )
+
+      filename = File.join( format_dir, format + CONFIG_EXT )
+      @processor.load_config( File.read( filename ), filename)
+
+      filename = File.join( lang_dir, lang + CONFIG_EXT )
+      @processor.load_config( File.read( filename ), filename )
+
+      @processor.load_config( File.read( userconfig ), userconfig ) if userconfig
+    end
+
+    def convert( resume )
+      ElementWrapper.new( REXML::Document.new( File.new( resume ) ).root, @processor, {} ).process!
+    end
+
+    private
+
+    def format_dir
+      File.join( @data_dir, 'format' )
+    end
+
+    def lang_dir
+      File.join( @data_dir, 'lang' )
+    end
+
+    def dir_list( dir )
+      Dir[File.join( dir, '*' + CONFIG_EXT )].collect {|name| File.basename( name, CONFIG_EXT ) }
+    end
+
+  end
+
+end

data/lib/xmlresume2x/processor.rb

@@ -0,0 +1,135 @@
+#
+# $Id: processor.rb 21 2004-12-09 17:44:52Z thomas $
+#
+#--
+#
+# xmlresume2x: converts an xml resume to various output formats
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'xmlresume2x/wrapper'
+
+module XMLResume2x
+
+  # This class serves as container for processors and keywords. Therefore it defines the methods
+  # which can be used in the configuration files.
+  class ResumeProcessor
+
+    # A hash of processors
+    attr_reader :processors
+
+    # A hash containing the assignments of XML elements to processors
+    attr_reader :assignments
+
+    # The language used for this ResumeProcessor
+    attr_accessor :lang
+
+    def initialize( lang )
+      @lang = lang
+      @keywords = Hash.new( '<UNDEFINED>' )
+      @processors = Hash.new( Proc.new {|e, options| get_children_value( e, options ) } )
+      @assignments = Hash.new
+      processor( :textItem => 'REXMLTextProcessor' ) {|e, options| get_value( e.value, options ) }
+    end
+
+    # Loads the configuration defined by the given string +src+.
+    def load_config( src, filename = '(eval)' )
+      instance_eval( src, filename )
+    end
+
+    # Adds a processor which should be defined using a block. +name+ is the name of the processor.
+    def add_processor( name, &block )
+      raise ArgumentError, "No block given" unless block_given?
+      @processors[name.to_s] = block
+    end
+
+    # Assigns elements to processors. +assignment+ has to be a Hash where the keys are XML resume
+    # element names and the values are processor names. If a block is supplied, then the XML resume
+    # elements are processed by the given block.
+    def processor( assignment, &block )
+      raise ArgumentError, "Argument has to be a Hash" unless Hash === assignment
+      assignment.each do |key, value|
+        add_processor( value, &block ) if block_given?
+        case key
+        when Array
+          key.each {|name| @assignments[name.to_s] = value }
+        when String
+          @assignments[key.to_s] = value
+        when Symbol
+          @assignments[key] = value
+        else
+          raise ArgumentError, "Key for assignment has to be Array or String or Symbol"
+        end
+      end
+    end
+
+    # Calls the processor +name+ on the element +item+ and optionally with +options+.
+    def call_processor( name, item, options = {} )
+      proc = @processors[name]
+      if proc.arity == 1
+        proc.call( item )
+      else
+        proc.call( item, options )
+      end
+    end
+
+    # Defines or retrieves a keyword. If +arg+ is a Hash, then the keywords in this Hash are added.
+    # If +arg+ is a Symbol, then the specified keyword is retrieved. The parameter +processed+
+    # specifies if the keyword should be processed as any other text.
+    def keyword( arg, processed = true )
+      case arg
+      when Symbol
+        processed ? get_value( @keywords[arg] ) : @keywords[arg]
+      when Hash
+        @keywords.update( arg )
+      else
+        raise ArgumentError, "Argument has to be a Symbol or a Hash"
+      end
+    end
+
+    # Returns the value of +item+ after being processed by the assigned processor.
+    def get_value( item, options = {} )
+      name, item = case item
+                   when ElementWrapper
+                     options = item.options.merge( options )
+                     [item.__element.name, item]
+                   when REXML::Element
+                     [item.name, ElementWrapper.new( item, self, options )]
+                   when REXML::Text
+                     [:textItem, item]
+                   when String
+                     [:text, item]
+                   when NilClass
+                     return nil
+                   else
+                     raise ArgumentError, "Not a valid argument class (#{item.class})"
+                   end
+      call_processor( @assignments[name], item, options )
+    end
+
+    # Returns the values of the processed children of +element+.
+    # *Returns*:: an array with all the values or if the <tt>:to_s</tt>
+    #             option is set, the array converted to a string, i.e. <tt>array.to_s</tt>
+    def get_children_value( element, options = {} )
+      arr = []
+      new_options = element.options.merge( options )
+      element.__element.each_child {|child| arr << get_value( child, new_options ) }
+      new_options[:to_s] ? arr.to_s : arr
+    end
+
+  end
+
+end

data/lib/xmlresume2x/wrapper.rb

@@ -0,0 +1,113 @@
+#
+# $Id: wrapper.rb 22 2004-12-10 18:21:39Z thomas $
+#
+#--
+#
+# xmlresume2x: converts an xml resume to various output formats
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+class Array
+
+  alias_method :old_join, :join
+  def join( sep = $, )
+    if sep.instance_of?( String ) || sep.instance_of?( NilClass )
+      old_join( sep )
+    else
+      arr = []
+      self.each_with_index {|e, i| arr << sep.clone if i > 0; arr << e}
+      arr
+    end
+  end
+
+  def separate_by( sep, sepLast )
+    result = self[0..-2].join( sep )
+    case self.length
+    when 0 then result
+    when 1 then self.last
+    when 2
+      if result.kind_of? String
+        result << sepLast.to_s << self.last.to_s
+      else
+        result << sepLast << self.last
+      end
+    end
+  end
+
+end
+
+module XMLResume2x
+
+  class ElementWrapperList < Array
+
+    def method_missing( name, *args )
+      return nil if self.length == 0
+      self[0].send( name.to_s, *args )
+    end
+
+    def process_all!( options = {} )
+      self.collect {|e| e.process!( options ) }
+    end
+
+  end
+
+  class ElementWrapper
+
+    attr_reader :options
+
+    def initialize( element, processor, options )
+      @element = element
+      @processor = processor
+      @options = options
+    end
+
+    def method_missing( name, *args )
+      name = name.to_s
+      if name =~ /^_/
+        name.sub!( /^_/, '' )
+        @processor.get_value( @element.attributes[name], @options )
+      elsif @element.elements[name]
+        list = ElementWrapperList.new
+        @element.each_element( name ) {|e| list << ElementWrapper.new( e, @processor, @options ) }
+        list
+      else
+        nil
+      end
+    end
+
+    def __element
+      @element
+    end
+
+    def process!( options = {} )
+      @processor.get_value( self, options )
+    end
+
+    def process_children!( options = {} )
+      @processor.get_children_value( self, options )
+    end
+
+    def text!
+      @processor.get_value( @element.text, @options )
+    end
+
+    def to_s
+      process!.to_s
+    end
+
+  end
+
+end

data/lib/xmlresume2x/xmlmarkup.rb

@@ -0,0 +1,104 @@
+#
+# $Id: xmlmarkup.rb 22 2004-12-10 18:21:39Z thomas $
+#
+#--
+#
+# xmlresume2x: converts an xml resume to various output formats
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+
+class XMLResume2x::ResumeProcessor
+
+  def tag( name, attr = nil, context = nil )
+    e = REXML::Element.new( name, context )
+    attr.each {|key, value| e.add_attribute( key, value )} if attr
+    e
+  end
+
+end
+
+class REXML::Parent
+
+  alias_method :old_add, :add
+
+  def add( object, *others )
+    if object.instance_of?( XMLResume2x::ElementWrapper ) || object.instance_of?( XMLResume2x::ElementWrapperList )
+      add( object.process! )
+    elsif object.instance_of? XMLResume2x::REXMLBuilder
+      add( object.element! )
+    elsif object.instance_of? Array
+      object.each {|o| add( o )}
+    elsif object.instance_of? String
+      old_add( REXML::Text.new( object ) )
+    else
+      old_add( object )
+    end
+    others.each {|o| add( o )}
+    self
+  end
+
+end
+
+class REXML::Element
+
+  def builder
+    XMLResume2x::REXMLBuilder.new( self )
+  end
+
+end
+
+
+class XMLResume2x::REXMLBuilder
+
+  instance_methods.each {|m| undef_method( m ) unless m =~ /^(__|instance_eval)|\?$/}
+
+  def initialize( element )
+    @element = element
+  end
+
+  def method_missing( name, *args, &block )
+    attrs = {}
+    content = nil
+    args.each do |a|
+      if a.instance_of? Hash
+        attrs.merge!( a )
+      else
+        content ||= []
+        content << a
+      end
+    end
+    new_elem = @element.add_element( name.to_s, attrs )
+    new_elem.add( content ) unless content.nil?
+    yield XMLResume2x::REXMLBuilder.new( new_elem ) if block_given?
+    self
+  end
+
+  def text!( str )
+    @element.add_text( str )
+    self
+  end
+
+  def add!( object, *others )
+    @element.add( object, *others )
+    self
+  end
+
+  def element!
+    @element
+  end
+
+end