davetron5000-daves-resume 0.1.1

data/bin/dr

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby
+
+COMMAND = ARGV.shift
+
+cli = "dr-#{COMMAND}"
+
+if (!system(cli,*ARGV))
+    cli = "bin/" + cli
+    if (!system(cli,*ARGV))
+        puts "Couldn't find #{cli}"
+        exit -1
+    end
+end

data/bin/dr-format

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby
+#
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib') 
+$: << File.expand_path(File.dirname(__FILE__) + '/../ext') 
+
+require 'rubygems'
+require 'commandline'
+require 'resume'
+require 'serializer'
+require 'formatter'
+require 'fileutils'
+require 'make_commandline_gemproof'
+
+include Resume
+
+class DavesResume < CommandLine::Application
+    def initialize
+        author "David Copeland"
+        synopsis "Usage: #{$0} --format file_format [file_format]* --resume resume_yaml_dir [--core core_name] [--name base_name]"
+        short_description "Resume builder and formatter"
+        long_description "This reads your resume in YAML and outputs it in a given file format (e.g. RTF).  This also allows you to specify multiple resume cores and to choose between them.  For example, if you are searching for a senior developer and a technical lead position, you might want to change your headline and summary, depending on the position. Further, you may want to customize which achievements of your post positions you focus on."
+
+        options :help
+        option :names => %w(--format -f), 
+            :opt_description => "Formats to generate for your resume",
+            :arg_description => "One or more format names matching existing templates",
+            :arity => [1,-1],
+            :opt_found   => get_args,
+            :opt_not_found => lambda {
+                puts synopsis
+                exit 
+            }
+        option :names => %w(--resume -r), 
+            :opt_description => "Sets the path to the resume YAML files",
+            :arity => [1,1],
+            :opt_found   => get_args,
+            :opt_not_found => lambda {
+                puts synopsis
+                exit 
+            }
+        option :names => %w(--filter), 
+            :opt_description => "Path to a ruby file that implements the 'Key Achievements' filter",
+            :arity => [1,1],
+            :opt_found   => get_args,
+            :opt_not_found => false
+
+        option :names => %w(--core -c), 
+            :opt_description => "Sets the core for this resume generation",
+            :arg_description => "Name of the core to use (should be in resume_dir named resume_CORENAME.yaml)",
+            :arity => [1,1],
+            :opt_found   => get_args,
+            :opt_not_found => false
+
+        option :names => %w(--name -n), 
+            :opt_description => "Controls the name of the generated file",
+            :arg_description => "Base name of the file(s) to generate (extension is based on formats selected)",
+            :arity => [1,1],
+            :opt_found   => get_args,
+            :opt_not_found => 'resume'
+    end
+
+    def main
+        serializer = Serializer.new
+        serializer.core_to_use = opt.core if opt.core
+        serializer.filter_file = opt.filter if opt.filter
+        formatter = Formatter.new(serializer.load(opt.resume),opt.name)
+        formatter.send(opt.format.to_sym)
+    end
+end

data/bin/dr-scaffold

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby
+
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib') 
+$: << File.expand_path(File.dirname(__FILE__) + '/../ext') 
+
+require 'rubygems'
+require 'commandline'
+require 'resume'
+require 'serializer'
+require 'formatter'
+require 'fileutils'
+require 'make_commandline_gemproof'
+
+include Resume
+
+class DavesResume < CommandLine::Application
+    def initialize
+        author "David Copeland"
+        synopsis "Usage: #{$0} [--force] --resume resume_dir"
+        short_description "Generates scaffold of a resume for Dave's Resume"
+        long_description "This will generate a series of YAML files that you can use as the basis for your resume.  You can create as many experience and education files as you like; these will all be picked up and sorted appropriately.  See the README for more"
+
+        options :help
+
+        option :flag, :names => %w(--force -f),
+            :opt_description => "Force overwrite of existing scaffold dirs"
+
+        option :names => %w(--resume -r), 
+            :opt_description => "Sets the path to put the resume YAML files",
+            :arity => [1,1],
+            :opt_found   => get_args,
+            :opt_not_found => lambda {
+                puts synopsis
+                exit 
+            }
+    end
+
+    def main
+        resume = Resume::Resume.scaffold
+        serializer = Serializer.new
+        scaffold_dir = opt.resume
+        if (opt.force || (!File.exist? scaffold_dir))
+            rm_rf(scaffold_dir)
+            mkdir(scaffold_dir)
+            serializer.store(scaffold_dir,resume)
+            puts "Your scaffold resume is in #{scaffold_dir}"
+        else
+            puts "#{scaffold_dir} exists, use --force to overwrite"
+        end
+    end
+end

data/ext/make_commandline_gemproof.rb

@@ -0,0 +1,19 @@
+require 'commandline'
+
+# Makes the inherited method not be so strict checking the app name
+class CommandLine::Application
+    class << self
+        alias old_inherited inherited
+
+        def inherited(child_class)
+            @@appname = caller[0][/.*:/][0..-2]
+            @@child_class = child_class
+            normalized_appname = @@appname.gsub(/^.*\//,"");
+            normalized_dollar0 = $0.gsub(/^.*\//,"");
+            if normalized_appname == normalized_dollar0
+                __set_auto_run
+            end
+        end
+    end
+end
+

data/ext/position_filter.rb

@@ -0,0 +1,40 @@
+class KeyAcheivementsFilter
+
+    attr_accessor :filter_config
+
+    def filter_achievements(achievements)
+        counts = Hash.new
+        developer_not_architect = Array.new
+        filtered = achievements.select() do |a|
+            if !a.tags || a.tags.empty?
+                filter_config.include_untagged_achievements
+            else
+                a.tags.each() { |t| counts[t] = counts[t] ? counts[t] += 1 : 1 }
+                developer_not_architect << a if (!a.tags.include? filter_config.primary_tag) && (a.tags.include? filter_config.alt_tag)
+                if (a.tags.include? :major)
+                    true
+                else
+                    ! ((a.tags & filter_config.achievement_tags).empty?)
+                end
+            end
+        end
+        if !counts[filter_config.primary_tag]
+            filtered = filtered | developer_not_architect
+        end
+        if filtered.size < filter_config.min_achievements
+            needed = filter_config.min_achievements - filtered.size()
+            needed.times() { |i| filtered << achievements[i] if achievements[i] && !filtered.include?(achievements[i]) }
+        elsif filtered.size > filter_config.max_achievements
+            filtered = filtered.select() do |a|
+                if !a.tags || a.tags.empty?
+                    true
+                else
+                    !a.tags.include?(:minor)
+                end
+            end
+        end
+        filtered
+    end
+end
+
+FILTER = KeyAcheivementsFilter.new

data/ext/string_tags.rb

@@ -0,0 +1,4 @@
+class String
+    # A list of arbitrary tags for this string (as symbols)
+    attr_accessor :tags
+end

data/lib/README.rdoc

@@ -0,0 +1,112 @@
+= Dave's Resume
+
+This is a set of small tools that allow you to manage your resume as a "database" of sorts, and publish it in various formats.  You can use it to maintain multiple resumes based on the same employment history and education, which can be handy for targeting certain jobs.
+
+= Quick Start
+
+    dr-scaffold -r my_resume_dir
+    dr-format -r my_resume_dir -f HTML
+
+<tt>resume.html</tt> now contains the resume generated by the scaffold.  To create you resume, you need to:
+
+1. Modify <tt>resume.yaml</tt> with your information
+2. Modify <tt>skills.yaml</tt> with your skillset (see below)
+3. Duplicate <tt>experience_Initech.yaml</tt> for each job you've held; this contains all the positions you held at that job, plus other information
+4. Duplicate <tt>education_Degree_Mill_U.yaml</tt> for each degree/education you wish to appear
+5. Duplicate (or delete) <tt>samples_Name_of_this_work_sample.yaml</tt> with any work samples
+
+You can generate in one of three formats:
+<tt>RTF</tt>:: - Rich Text which can be read by Word
+<tt>HTML</tt>:: - A basic HTML version
+<tt>Markdown</tt>:: - a Markdown[http://www.daringfireball.com/projects/markdown] version
+
+
+= YAML format
+
+Basically, this is the serialized form of the classes in <tt>resume.rb</tt>, as produced by the standard YAML serializer that comes with Ruby.
+
+So, if you edit this and get the formatting wrong, you get obtuse errors.  Be gentle and thank yourself you don't have to do it in Word.  Also consider using source control.  Now that you've decided to store your resume in a sane, text-based format, you get all the benefits of version control, including diffs and reverting to known versions.
+
+Basically, the resume is:
+
+Core:: (in <tt>resume.yaml</tt>) - This has stuff like your name, address, summary, etc.  If you wish to have multiple resumes, you will duplicate this file naming it <tt>resume_NAME.yaml</tt> where _NAME_ is the "core name" you can specify on the command-linen to <tt>dr-format</tt>
+Skill Set:: (in <tt>skills.yaml</tt>) - This is a database of your skills, with an experience level and a number of years experience.    These determine the sort order in your resume output.  Basically, skills with which you are an <tt>:expert</tt> are shown first, sorted by years of experience. This is followed by skills where you are <tt>:intermediate</tt>.  <tt>:novice</tt> skills show up in their own category called "Some Experience With".  This allows you to include skills you've used, but be clear where your strengths lie.
+            * The accepted levels currently are:
+              <tt>:novice</tt>:: skills show up in "Some Experience With"
+              <tt>:intermediate</tt>:: skills show up last in their category
+              <tt>:expert</tt>:: skills show up first in their category
+            * The categories are currently hard-coded (sorry) and any skill not in a category won't show up (this is on my todo list).  The categories are:
+              <tt>:languages</tt>:: Programming languages, e.g.
+              <tt>:apis</tt>:: APIs, standards, etc.
+              <tt>:tools</tt>:: Specific technology tools
+              <tt>:databases</tt>:: Relational databases
+              <tt>:operating_systems</tt>:: Specific operating systems
+Experience:: any file that starts with <tt>experience_</tt> and ends in <tt>.yaml</tt> will get picked up.  Things will be sorted properly (in reverse chronological order) for you.  A Job consists of one or more positions, and the formatter should be smart about handling jobs with only one position.
+             * Acheivements can be tagged and you can use these tags to control your output (see below)
+Education:: works like Experience files starting with <tt>education_</tt> will get picked up and sorted reverse chronologically
+Samples:: this is just a name and a link, and only shows up in the Markdown and HTML version (though you are free to modify the RTF version).
+References:: this isn't used anywhere right now, but any file starting with <tt>reference_</tt>  and ending with <tt>.yaml</tt> will get picked up.
+
+= Tweaking the output
+
+The output is created via ERB templates.  Currently, these templates are part of the gem installation and not terribly tweakable.  In the future you should be able to create your own.  If you are feeling up for it, you can tweak those in the gem install directly.
+
+= Maintaining multiple resumes
+
+The idea of Dave's Resume is that your resume database keeps *all* relevant data about your work experience.  The realities of the job market are that you need to focus your resume for a particular job.  As such, you might not want to include everything in your past on your resume.  For example, suppose you had a job with these three key achievements:
+
+* Designed and Developed Enterprise Java Application for issue management
+* Patched Windows machines for HR staff
+* Conducted regular design and code reviews
+
+If you were going for a Senior Java Developer position, you might not want to include the achievement regarding patching Windows machines (conversely if you were going for a network administrator position, maybe you would).
+
+Filter allows you to customize this behavior.
+
+You have two means of doing this:
+
+* Create multiple "resume cores" with different headlines and summaries.  Here, just create, say <tt>resume_javadev.yaml</tt> and <tt>resume_networkadmin.yaml</tt> instead of the <tt>resume.yaml</tt> the scaffolding created.  Modify these as needed and then do <tt>dr-format -r resume_dir -f RTF --core javadev</tt> to generate your Java Developer focused resume
+* Create filtering code in Ruby to filter your "achievements".  Here you create a class that implements <tt>filter_acheivements</tt>.  It takes an array of strings (where tags are available via <tt>String=tags</tt>) and should return an array of strings, filtered based on your criteria (presumably the tags in your database).  Create an instance of this class in your file and assign it to the <tt>FILTER</tt> constant.  Pass the path to this file to the <tt>--filter</tt> argument of <tt>dr-format</tt>.  
+
+There is a default filter available that might do what you need
+
+== Included Acheivement Filter
+
+The included filter works as follows:
+
+1. Create a core for the job (e.g. <tt>techlead_resume.yaml</tt>)
+1. Create a config file in your resume dir named <tt>config_techlead.yaml</tt> (e.g.) that looks like so:
+    --- !ruby/object:Resume::ResumeConfig 
+    achievement_tags: 
+    - :lead
+    - :pm
+    - :developer
+    alt_tag: :architect
+    core_name: developer
+    include_untagged_achievements: true
+    max_achievements: 5
+    min_achievements: 3
+    primary_tag: :developer
+3. Modify the contents to your liking based upon how you've created your database and taking into account the algorithm.
+
+The algorithm works like this:
+
+1. The achievements for a position are filtered first based upon <tt>achievement_tags</tt>.  Anything not tagged with one of those tags is omitted.  Untagged acheivements are included if you set <tt>include_untagged_achievements</tt> to true, otherwise they are not included
+2. Anything tagged <tt>:major</tt> is included regardless of the above algorithm
+3. If no achievement was tagged with the tag specified in <tt>primary_tag</tt>, all achievements tagged with the tag specified in <tt>alt_tag</tt> are included.
+4. If the number of achievements is below <tt>min_achievements</tt>, random achievements are added to make the list the minimum size
+5. If the number of achievements is above <tt>max_achievements</tt>, any achievement tagged <tt>:minor</tt> is removed
+
+So, the way to take advantage of this is:
+
+* Tag <tt>:major</tt> on anything you always want to appear; your proudest moments
+* Tag <tt>:minor</tt> anything you don't care about but might need to fill out your resume
+* Tag every achievement with fine-grained tags relevant to the positions you are pursuing
+
+To use this filter, specify <tt>--filter position_filter --core techlead</tt> (or whatever you named your core and filter config file).
+
+= TODO
+
+* don't hardcode the skill categories
+* make scaffolding more fine-grained
+* Allow for user-generated templates

data/lib/formatter.rb

@@ -0,0 +1,53 @@
+require 'erb'
+module Resume
+
+    # Handles formatting the resume using ERB templates.
+    # Create an instance of this class, then call a method named for your template.
+    # In +templates_dir+, if a file is named Xyz.erb, formatter.Xyz will run the resume through
+    # the template.  If an argument is passed to the method, the resulting file
+    # will be copied to the file named by the argument.
+    #
+    #     formatter = Formatter.new(resume,"MyResume","/home/davec/templates")
+    #     formatter.doc("DavesResume.doc")
+    #
+    # This will try to find +/home/davec/templates/doc.erb+ and use it to create your resume.  The
+    # resulting file would be +MyResume.doc+ and that file would be copied to +DavesResume.doc+
+    class Formatter
+        TEMPLATES_DEFAULT = File.expand_path(File.dirname(__FILE__) + '/../templates') 
+        # Create a new Formatter for a given resume
+        #
+        # +resume+:: The Resume object to format
+        # +resume_name+:: The basename of the files that will be output
+        # +templates_dir+:: location of your templates
+        def initialize(resume,resume_name="resume",templates_dir=TEMPLATES_DEFAULT)
+            @resume = resume
+            @resume_name = resume_name
+            @templates_dir = templates_dir
+        end
+
+        # Does the formatting based on the method name, if the template is found.  Case matters
+        def method_missing(method,*args)
+            type = method.to_s
+            template_file = "#{@templates_dir}/#{type}.erb"
+            if (File.exists? template_file)
+                template = ""
+                File.open(template_file) do |input|
+                    input.readlines.each() do |line|
+                        template += line
+                    end
+                end
+                type_template = ERB.new(template)
+                type_data = type_template.result(@resume.get_binding)
+                file_name = @resume_name + "." + type.downcase
+                File.open(@resume_name + "." + type.downcase,'w') do |file|
+                    file.puts type_data
+                end
+                if args && !args.empty?
+                    cp(file_name,args[0])
+                end
+            else
+                raise "There is no template for #{type}"
+            end
+        end
+    end
+end

data/lib/resume.rb

@@ -0,0 +1,399 @@
+require 'string_tags.rb'
+
+module Resume
+# The core elemens of the resume
+class ResumeCore
+    # Contact info, such as name and address
+    attr_accessor :contact_info
+    # Headline statement (String)
+    attr_accessor :headline
+    # Summary of qualifications (String)
+    attr_accessor :summary
+    # The name of this resume core, for conditional creation
+    attr_accessor :name
+
+    def ResumeCore.scaffold
+        core = ResumeCore.new
+        core.contact_info = ContactInfo.scaffold
+        core.headline = "Sum up yourself here in this headline"
+        core.summary = "Provide a somewhat longer summary, in paragraph form, of why you are so awesome"
+        core
+    end
+end
+
+# The entire resume
+class Resume
+    # a ResumeCore object
+    attr_accessor :core
+    # Array of Job objects
+    attr_accessor :experience
+    # A SkillSet
+    attr_accessor :skills
+    # Array of Education objects
+    attr_accessor :education
+    # Array of Reference objects
+    attr_accessor :references
+    # Array of Sample objects
+    attr_accessor :samples
+
+    def initialize
+        @samples = Array.new
+        @references = Array.new
+        @education = Array.new
+        @experience = Array.new
+    end
+
+    def get_binding
+        binding
+    end
+
+    def Resume.scaffold
+        resume = Resume.new
+        resume.core = ResumeCore.scaffold
+        resume.experience << Job.scaffold
+        resume.experience << Job.scaffold("Penetrode")
+        resume.skills = SkillSet.scaffold
+        resume.education << Education.scaffold
+        resume.education << Education.scaffold("Rhode Island School of Design")
+        resume.references << Reference.scaffold("John Q. Manager")
+        resume.references << Reference.scaffold("Jimmy Jones Bossman")
+        resume.samples << Sample.scaffold
+        resume.samples << Sample.scaffold
+        resume
+    end
+end
+
+# A sample of work, avaiable via the internet
+class Sample
+    attr_accessor :name
+    attr_accessor :url
+
+    def Sample.scaffold
+        sample = Sample.new
+        sample.name = "Name of this work sample"
+        sample.url = "http://www.google.com"
+        sample
+    end
+
+    def <=>(other_sample)
+        return 1 if !other_sample 
+        @name <=> other_sample.name
+    end
+
+end
+# Represents a personal reference
+class Reference
+    attr_accessor :name
+    attr_accessor :phone
+    attr_accessor :email
+    attr_accessor :company
+    attr_accessor :title
+    attr_accessor :relationship
+
+    def safe_email
+        return @email.gsub(/@/," at ").gsub(/\./," dot ")
+    end
+
+    def Reference.scaffold(name = nil)
+        ref = Reference.new
+        ref.name = name 
+        ref.name = "Some Guy's Name" if !name
+        ref.phone = rand(10).to_s + rand(10).to_s + rand(10).to_s + "-555-1212"
+        ref.email = "someguy@someplace.com"
+        ref.company = "Some Place"
+        ref.relationship = "Boss"
+        ref.title = "VP, Widgets"
+        ref
+    end
+end
+
+# Represents all skills
+class SkillSet
+
+    @@categories = {
+        :languages=> "Languages",
+        :apis=> "APIs",
+        :tools=>"Tools",
+        :databases=>"Databases",
+        :operating_systems=>"OSes"
+    }
+
+    @@category_order = [
+        :languages,
+        :apis,
+        :tools,
+        :databases,
+        :operating_systems,
+    ]
+
+    def SkillSet.category_order; @@category_order; end
+    def SkillSet.categories; @@categories; end
+    # Returns the labels for the categories in order
+    def SkillSet.category_labels_order
+        labels = Array.new
+        @@category_order.each() { |c| labels << @@categories[c] }
+        labels
+    end
+
+    # Hash of category to skill objects
+    attr_accessor :skills
+
+    def initialize
+        @skills = Hash.new
+    end
+
+    def all_novice_skills
+        novice_skills = Array.new
+        skills.each() do |k,v|
+            novice_skills = novice_skills | v.select() { |x| x.experience_level == :novice }.sort().reverse()
+        end
+        novice_skills
+    end
+
+    # Returns a map of skill categories to arrays of skills
+    def non_novice_skills_by_category
+        non_novice = Hash.new
+        SkillSet.category_order.each() do |category|
+            non_novice[SkillSet.categories[category]] = skills[category].select() { |x| x.experience_level != :novice }.sort().reverse()
+        end
+        non_novice
+    end
+
+    def SkillSet.scaffold
+        rand_skills = {
+            :languages => "COBOL",
+            :apis => "MOTIF",
+            :tools => "Turbo Pascal",
+            :databases => "Sybase",
+            :operating_systems => "OS/2",
+        }
+        set = SkillSet.new
+        @@category_order.each() do |c|
+            set.skills[c] = Array.new
+            set.skills[c] << Skill.scaffold(rand_skills[c])
+        end
+        set
+    end
+end
+
+# Represents a skill, such as "Java"
+class Skill
+    attr_accessor :name
+    attr_accessor :experience_level
+    attr_accessor :years_experience
+
+    def initialize(name,exp)
+        @name = name
+        @experience_level = exp
+    end
+
+    def <=>(other_skill)
+        return 1 if (other_skill == nil)
+        if (other_skill.experience_level == @experience_level)
+            if other_skill.years_experience 
+                return @years_experience <=> other_skill.years_experience
+            elsif @years_experience
+                return 1
+            else
+                return 0
+            end
+        else
+            return 1 if (@experience_level == :expert)
+            return 1 if (@experience_level == :intermediate && other_skill.experience_level == :novice)
+            return -1;
+        end
+    end
+
+    def Skill.scaffold(name=nil)
+        exp = {
+            0 => :novice,
+            1 => :intermdiate,
+            2 => :expert,
+        }
+        skill = Skill.new(name,exp[rand(3)])
+        skill.name = "EBCIDIC" if !name
+        skill.years_experience = rand(10) + 1
+        skill
+    end
+
+    def to_s
+        @name
+    end
+end
+
+# Represents a degree earned or other college-type educational experience
+class Education
+    attr_accessor :name
+    attr_accessor :degree
+    attr_accessor :year_graduated
+    attr_accessor :major
+    attr_accessor :other_info
+
+    def Education.scaffold(name=nil)
+        ed = Education.new
+        ed.name = name
+        ed.name = "Degree Mill U" if !name
+        ed.degree = "Bachelor of Fine Arts"
+        ed.year_graduated = 1969
+        ed.major = "Underwater Basketweaving"
+        ed.other_info = "Thesis: Basketweaving simplified"
+        ed
+    end
+
+    def <=>(other_education)
+        return 1 if !other_education
+        return year_graduated <=> other_education.year_graduated
+    end
+end
+
+# Contact information, such as name, email, address
+class ContactInfo
+    attr_accessor :name
+    attr_accessor :email
+    # An Address object
+    attr_accessor :address
+    attr_accessor :phone
+
+    def safe_email
+        return @email.gsub(/@/," at ").gsub(/\./," dot ")
+    end
+
+    def ContactInfo.scaffold
+        contact = ContactInfo.new
+        contact.name = "John J. Programmer"
+        contact.email = "lacky@whatyouneed.com"
+        contact.address = Address.scaffold
+        contact.phone = "202-555-1212"
+        contact
+    end
+end
+
+class Address
+    attr_accessor :street
+    attr_accessor :city
+    attr_accessor :state
+    attr_accessor :zip
+
+    def Address.scaffold
+        address = Address.new
+        address.street = "124 Any St, #666"
+        address.city = "Sometown"
+        address.state = "AZ"
+        address.zip = "94118"
+        address
+    end
+end
+
+# A job that you had, i.e. a time working for a company
+class Job
+    # Name of the company
+    attr_accessor :name
+    attr_accessor :date_range
+    # Location, e.g. San Francisco, VA
+    attr_accessor :location
+    # Array of Position objects
+    attr_accessor :positions 
+
+    def initialize
+        @positions = Array.new
+    end
+
+    def Job.scaffold(name="Initech")
+        job = Job.new
+        job.name = name
+        job.date_range = DateRange.scaffold(2000,2003)
+        job.location = "San Francisco, CA"
+        job.positions << Position.scaffold("Lead Copy Boy",2001)
+        job.positions << Position.scaffold("Copy Boy",2000)
+        job
+    end
+
+    def <=>(other_position)
+        return 1 if !other_position
+        return 1 if !other_position.date_range
+        return date_range <=> other_position.date_range
+    end
+end
+
+# 
+
+# A position held within a job
+class Position
+    # Job title
+    attr_accessor :title
+    attr_accessor :date_range
+    # Description of the position's requirements
+    attr_accessor :description
+    # Array of achievements
+    attr_accessor :achievements
+
+    def initialize
+        @achievements = Array.new
+    end
+
+    def Position.scaffold(name,year)
+        position = Position.new
+        position.title = name
+        #position.date_range = DateRange.new
+        #position.date_range.start_date = Date.civil(year,01,01);
+        #position.date_range.end_date = Date.civil(year,12,01);
+        position.description = "Enter in a description of the position you held"
+        position.achievements << "Enter your most important achievements first"
+        position.achievements << "Follow with additional ones, making sure to indicate the result of your actions"
+        position.achievements[0].tags = Array.new
+        position.achievements[0].tags << :major
+        position.achievements[0].tags << :architect
+        position.achievements[1].tags = Array.new
+        position.achievements[1].tags << :architect
+        position
+    end
+    
+    def <=>(other_position)
+        return 1 if !other_position
+        return 1 if !other_position.date_range
+        return date_range <=> other_position.date_range
+    end
+end
+
+class DateRange
+    attr_accessor :start_date
+    attr_accessor :end_date
+
+    def DateRange.scaffold(year1,year2)
+        range = DateRange.new
+        range.start_date=Date.ordinal(year1,1)
+        range.end_date=Date.ordinal(year2,1)
+        range
+    end
+
+    def <=>(other_range)
+        return @start_date <=> other_range.start_date
+    end
+
+    def to_s
+        if (@end_date)
+            return "#{start_date.month}/#{start_date.year} - #{end_date.month}/#{end_date.year}"
+        else
+            return "#{start_date.month}/#{start_date.year} - present"
+        end
+    end
+end
+
+# Configuration for generating a resume
+class ResumeConfig
+    # Primary achievement tag to make sure gets included
+    attr_accessor :primary_tag
+    # Alternate achievement tag to make sure gets included if the primary tag isn't used
+    attr_accessor :alt_tag
+    # List of tags to include
+    attr_accessor :achievement_tags
+    # Minimum number of achievements per position
+    attr_accessor :min_achievements
+    # Maximum number of achievements per position
+    attr_accessor :max_achievements
+    # If false, untagged achievements are ignore
+    attr_accessor :include_untagged_achievements
+    attr_accessor :core_name
+end
+
+end

data/lib/serializer.rb

@@ -0,0 +1,121 @@
+require 'yaml'
+require 'resume'
+require 'fileutils'
+
+include FileUtils
+module Resume
+# Serializes a resume to/from YAML
+class Serializer
+
+    attr_accessor :experience_prefix
+    attr_accessor :education_prefix
+    attr_accessor :references_prefix
+    attr_accessor :samples_prefix
+    attr_accessor :core_prefix
+    attr_accessor :skills_prefix
+    attr_accessor :core_to_use
+    attr_accessor :filter_file
+
+    def initialize
+        @experience_prefix='experience'
+        @education_prefix='education'
+        @references_prefix='references'
+        @samples_prefix='samples'
+        @core_prefix='resume'
+        @skills_prefix='skills'
+    end
+
+    # Loads the resume artifacts from the given directory
+    def load(dir)
+        if (!File.exists?(dir))
+            raise "#{dir} doesn't exist"
+        end
+
+        resume = Resume.new
+        cores = read_cores(dir,core_prefix)
+        if (cores.size > 1)
+            if (core_to_use)
+                cores.each() { |core| resume.core = core if core.name == core_to_use }
+            else
+                raise "You must specify a core resume to use since there are #{cores.size} of them"
+            end
+        else
+            resume.core = cores[0]
+        end
+        raise "#{core_to_use} didn't match any resumes" if !resume.core
+        config_filename = "#{dir}/config_#{core_to_use}.yaml"
+        config = File.open(config_filename) { |yf| YAML::load( yf ) } if File.exists?(config_filename)
+        resume.skills = File.open( "#{dir}/#{skills_prefix}.yaml" ) { |yf| YAML::load( yf ) } if File.exists?("#{dir}/#{skills_prefix}.yaml")
+        resume.experience = read(dir,experience_prefix)
+        warn "No experience detected" if resume.experience.size == 0
+        resume.education = read(dir,education_prefix)
+        resume.references = read(dir,references_prefix)
+        resume.samples = read(dir,samples_prefix)
+        resume.experience.sort!.reverse!
+        resume.education.sort!.reverse!
+        resume.samples.sort!.reverse!
+        resume.experience.each() do |xp|
+            xp.positions.each() do |position|
+                if (filter_file)
+                    require filter_file
+                    if (FILTER.respond_to? :filter_config=)
+                        FILTER.filter_config=config
+                    end
+                    position.achievements = FILTER.filter_achievements(position.achievements)
+                end
+            end
+            xp.positions.sort!.reverse!
+        end
+        return resume
+    end
+
+    def read(dir,base_name,allow_prefix_only=false)
+        list = Array.new
+        files = Dir.glob("#{dir}/#{base_name}_*.yaml")
+        if (allow_prefix_only)
+            prefix_only_name = "#{dir}/#{base_name}.yaml";
+            files << prefix_only_name if File.exists? prefix_only_name
+        end
+        files.each do |file|
+            list << File.open( file ) { |yf| YAML::load( yf ) }
+        end
+        list
+    end
+
+    def read_cores(dir,base_name)
+        return read(dir,base_name,true)
+    end
+
+    # Stores the resume artifacts to the given directory.
+    def store(dir,resume)
+        if File.exists?(dir)
+            rm(Dir.glob("#{dir}/*.yaml"))
+        else
+            mkdir(dir)
+        end
+        File.open("#{dir}/resume.yaml",'w') { |out| YAML::dump(resume.core,out) }
+        dump(dir,"experience",resume.experience)
+        dump(dir,"education",resume.education)
+        dump(dir,"reference",resume.references)
+        dump(dir,"samples",resume.samples)
+        File.open("#{dir}/skills.yaml",'w') { |out| YAML::dump(resume.skills,out) }
+    end
+
+    def dump(dir,base_name,items)
+        if (items && !items.empty?)
+            count = 1
+            items.each() do |item|
+                filename = base_name + "_"
+                if (item.respond_to? :name)
+                    filename += item.name.gsub(/\//,"_").gsub(/\s/,"_")
+                else
+                    filename += count.to_s
+                end
+                filename += ".yaml"
+                File.open("#{dir}/#{filename}",'w') { |out| YAML::dump(item,out) }
+                count += 1
+            end
+        end
+    end
+end
+end

data/templates/HTML.erb

@@ -0,0 +1,70 @@
+<html>
+<head>
+<title>Resume of <%= @core.contact_info.name %></title>
+</head>
+<body>
+<h1><%= @core.contact_info.name %></h1>
+
+<ul>
+<li><b>Address:</b> <%= @core.contact_info.address.city %>, <%= @core.contact_info.address.state %> <%= @core.contact_info.address.zip %>
+<li><b>Phone:</b> <%= @core.contact_info.phone %>
+<li><b>Email:</b> <%= @core.contact_info.safe_email %>
+</ul>
+<hr>
+<p style="font-size: 110%; font-weight: bold">
+<%= @core.headline %>
+</p>
+
+<h2>Summary</h2>
+<p style="font-style:italic">
+<%= @core.summary %>
+</p>
+<h2>Skills</h2>
+<table>
+<% 
+non_novice_skills = @skills.non_novice_skills_by_category
+SkillSet.category_labels_order.each() do |category|
+    these_skills = non_novice_skills[category] 
+%>
+<tr><td><b><%= category %></b></td><td><%= these_skills.join(", ") %></td></tr><% end %>
+<% if (!@skills.all_novice_skills.empty?) %><tr><td><i>Some experience with</i></td>
+<td><%= @skills.all_novice_skills.join(", ") %></td></tr><% end %>
+</table>
+
+<h2>Experience</h2>
+
+<% @experience.each() do |job| %>
+<h3><%= job.name %>(<%= job.location %>) <%= (!job.positions || job.positions.size != 1) ? "<i>#{job.date_range.to_s}</i>" : '' %></h3>
+    <% job.positions.each() do |position| %>
+<h4><%= position.title %></h4>
+<i><%= position.date_range.to_s %></i>
+<p>
+<b>Description:</b><%= position.description %>
+</p>
+<p>
+Key Achievements:
+<ul>
+        <% position.achievements.each() do |achievement| %>
+<li><%= achievement %></li>
+        <% end %>
+</ul>
+</p>
+    <% end %>
+<% end %>
+
+<h2>Education</h2>
+<% @education.each() do |school| %>
+<h3><%= school.name %> - <%= school.degree %>, <%= school.major %>, <%= school.year_graduated %></h3>
+    <% if school.other_info %>
+<p><%= school.other_info %></p>
+    <% end %><% end %>
+<% if @samples && !@samples.empty? %>
+<h2>Samples</h2>
+<ul>
+<% @samples.each() do |sample| %>
+<li><a href="<%= sample.url %>"><%= sample.name %></a></li>
+<% end %>
+<% end %>
+</ul>
+</body>
+</html>

data/templates/Markdown.erb

@@ -0,0 +1,49 @@
+# <%= @core.contact_info.name %>
+
++ **Address:** <%= @core.contact_info.address.city %>, <%= @core.contact_info.address.state %> <%= @core.contact_info.address.zip %>
++ **Phone:** <%= @core.contact_info.phone %>
++ **Email:** <%= @core.contact_info.safe_email %>
+
+* * *
+**<%= @core.headline %>**
+## Summary
+
+<%= @core.summary %>
+## Skills
+
+<% 
+non_novice_skills = @skills.non_novice_skills_by_category
+SkillSet.category_labels_order.each() do |category|
+    these_skills = non_novice_skills[category] 
+%>
++ **<%= category %>**: <%= these_skills.join(", ") %><%end %>
+<% if (!@skills.all_novice_skills.empty?) %>+ *Some experience with*: <%= @skills.all_novice_skills.join(", ") %><% end %>
+
+## Experience
+
+<% @experience.each() do |job| %>
+### <%= job.name %>(<%= job.location %>) <%= (!job.positions || job.positions.size != 1) ? "_#{job.date_range.to_s}_" : '' %>
+    <% job.positions.each() do |position| %>
+#### <%= position.title %>
+_<%= position.date_range.to_s %>_
+
+_Description:_ <%= position.description %>
+
+Key Achievements:
+        <% position.achievements.each() do |achievement| %>
++ <%= achievement %><% end %>
+    <% end %>
+<% end %>
+
+## Education
+<% @education.each() do |school| %>
+### <%= school.name %> - <%= school.degree %>, <%= school.major %>, <%= school.year_graduated %>
+    <% if school.other_info %>
+<%= school.other_info %>
+    <% end %><% end %>
+
+<% if @samples && !@samples.empty? %>
+## Samples
+<% @samples.each() do |sample| %>
+* [<%= sample.name %>](<%= sample.url %>)<% end %>
+<% end %>

data/templates/RTF.erb

@@ -0,0 +1,182 @@
+{\rtf1\ansi\deff0\deflang2057\plain\fs24\fet1
+{\fonttbl
+{\f0\fswiss Georgia;}
+{\f1\fswiss Helvetica;}
+}
+{\info
+{\createim\yr2008\mo10\dy26\hr14\min58}
+}
+{\footer 
+{\i\fs16
+Resume of <%= @core.contact_info.name %>, generated by http://github.com/davetron5000/daves-resume
+}}
+\paperw12247\paperh15819\margl1800\margr1440\margt1440\margb1440
+{\pard\ql\li-360
+{\b\f1\fs38
+<%= @core.contact_info.name %>
+}
+\par}
+{\pard\ql
+<%= @core.contact_info.address.city %>, <%= @core.contact_info.address.state %> <%= @core.contact_info.address.zip %>
+\par}
+{\pard\ql
+<%= @core.contact_info.phone %>
+\par}
+{\pard\ql
+<%= @core.contact_info.email %>
+\par}
+{\pard
+ 
+\par}
+{\pard\b\fs24
+<%= @core.headline %>
+\par}
+{\pard
+ 
+\par}
+{\pard\ql\li-360
+{\b\f1\fs34
+Summary
+}
+\par}
+{\pard
+ 
+\par}
+{\pard\ql
+{\i\fs22
+<%= @core.summary %>
+}
+\par}
+{\pard
+ 
+\par}
+{\pard\ql\li-360
+{\b\f1\fs34
+Skills
+}
+\par}
+{\pard
+ 
+\par}
+<% 
+non_novice_skills = @skills.non_novice_skills_by_category
+SkillSet.category_labels_order.each() do |category|
+    these_skills = non_novice_skills[category] 
+%>
+\trowd\tgraph100
+\cellx1440
+\cellx8640
+\pard\intbl
+{\b\fs18
+<%= category %>
+}
+\cell
+\pard\intbl
+{\fs18
+<%= these_skills.collect() { |item| item = item.experience_level == :expert ? "\\b #{item.to_s} \\plain\\fs18" : item}.join(", ") %>
+}
+\cell
+\row
+<% end %>
+<% if (!@skills.all_novice_skills.empty?) %>
+\trowd\tgraph100
+\cellx1440
+\cellx8640
+\pard\intbl
+{\b\fs18
+Exposure to:
+}
+\cell
+\pard\intbl
+{\fs18
+<%= @skills.all_novice_skills.join(", ") %>
+}
+\cell
+\row
+<% end %>
+{\pard
+ 
+\par}
+{\pard\ql\li-360
+{\b\f1\fs34
+Experience
+}
+\par}
+{\pard
+ 
+\par}
+
+<% @experience.each() do |job| %>
+{\pard\ql\li-180
+{\b\fs24
+<%= job.name %>
+}
+\par}
+{\pard\ql\li-180
+<%= job.location %> - <%= job.date_range.to_s %>
+\par}
+<% job.positions.each() do |position| %>
+{\pard\fs22
+{\ul
+<%= position.title %>	<%= position.date_range.to_s %>
+}
+\par}
+{\pard
+ 
+\par}
+{\pard
+{\i
+{\fs18
+{\b
+Description: 
+}
+<%= position.description %>
+}
+}
+\par}
+{\pard
+ 
+\par}
+{\pard
+{\fs18
+{\b
+Key Achievements:
+}
+}
+\par}
+<% position.achievements.each() do |achievement| %>
+{\pard\ql\li360\fi-360\tqr\tx720\tqr\tx1080\tqr\tx1440\tqr\tx1800\tqr\tx2160\tqr\tx2520\tqr\tx2880\tqr\tx3240\tqr\tx3600\tqr\tx3960
+{\fs18
+- 	<%= achievement %>
+}
+\par}
+<% end %>
+{\pard
+ 
+\par}
+<% end %>
+<% end %>
+{\pard
+ 
+\par}
+{\pard\ql\li-360
+{\b\f1\fs34
+Education
+}
+\par}
+{\pard
+ 
+\par}
+<% @education.each() do |school| %>
+{\pard\b\fs24
+<%= school.name %> - <%= school.degree %>, <%= school.major %>, <%= school.year_graduated %>
+\par}
+{\pard\ql\li360
+<% if school.other_info %>
+{\i\fs18
+<%= school.other_info %>
+}
+<% end %>
+\par}
+<% end %>
+}

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: davetron5000-daves-resume
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- David Copeland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: commandline
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.10
+    version: 
+description: 
+email: davidcopeland@naildrivin5.com
+executables: 
+- dr
+- dr-format
+- dr-scaffold
+extensions: []
+
+extra_rdoc_files: 
+- lib/README.rdoc
+files: 
+- ext/make_commandline_gemproof.rb
+- ext/position_filter.rb
+- ext/string_tags.rb
+- lib/formatter.rb
+- lib/resume.rb
+- lib/serializer.rb
+- templates/HTML.erb
+- templates/Markdown.erb
+- templates/RTF.erb
+- lib/README.rdoc
+has_rdoc: true
+homepage: http://www.naildrivin5.com
+post_install_message: 
+rdoc_options: 
+- --title
+- Dave's Resume Build and Formatter
+- --main
+- lib/README.rdoc
+require_paths: 
+- lib
+- ext
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Command Line tools to manage your resume and generate it in various formats
+test_files: []
+