resme 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88b2d8e225f97233ed991e95c8be2798b982d803941dacb7fd71b623a32e7822
-  data.tar.gz: 7f44a0bf98b3e49b33fce8924ae74545aa6591bfec53f1952aa9067167a8079c
+  metadata.gz: d8abd7d17f0d2b9a777cba680826c21d6ee882f3f3df0c74ba086e1d617d4b6b
+  data.tar.gz: b34b33c2f2d0f3beae3bef713efba2e39b05537d8a208380e6392271e0cbcb09
 SHA512:
-  metadata.gz: e0bdffd6b716cc6056c158a1672144343a66674c5371136d70c302d6e338279e0e582f0fbd126e577967d6f668557537f6732102faad014ec3478d87c4e2cd9b
-  data.tar.gz: 8feff2a7f410655dffc1199c6b47d9358acbaf5f0450715608b95dc393ec0ab2a25fc53b87a3accac0e047cca05c7ac2e02c0e2f710051b4af7bcde44e46180c
+  metadata.gz: fe74aa311a4dd110c26a0760cf6d2f8cb1ba1ee8e587f2a64d00ff6aa420a2a7f6c37b1eec392ddf1b28abbe49ffb94d6b26d5f43f2797ba9fd7cc9874ebf5c1
+  data.tar.gz: 3f2ae60c5c8a4e7f8135aa7f43aafa081f913dc8dd6c1b4c6065606447a41b6afe414ae4f32e0541fc06284227d94628f31f59e80af02aee2147c054032137c8

data/.gitignore

@@ -1,11 +1,8 @@
 /.bundle/
 /.yardoc
-/Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
 /tmp/
-*~
-*.bak

data/Gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
 # Specify your gem's dependencies in resme.gemspec
 gemspec
+
+gem "rake", "~> 12.0"

data/README.org

@@ -0,0 +1,245 @@
+#+TITLE: RESME - A Resume Generator
+#+AUTHOR: Adolfo Villafiorita
+#+DATE: <2020-07-14 Tue>
+#+STARTUP: showall
+
+Keep your resume in YAML and output it in various formats, including
+Org Mode, Markdown, JSON, and the Europass XML format.
+
+The rendering engine is based on ERB. This simplifies the creation of
+new output formats (and extending/modifying the YML structure to one's
+needs).
+
+** Installation
+   :PROPERTIES:
+   :CUSTOM_ID: installation
+   :END:
+
+Add this line to your application's Gemfile:
+
+#+BEGIN_SRC ruby
+      gem 'resme'
+#+END_SRC
+
+And then execute:
+
+#+BEGIN_EXAMPLE
+  $ bundle
+#+END_EXAMPLE
+
+Or install it yourself as:
+
+#+BEGIN_EXAMPLE
+  $ gem install resme
+#+END_EXAMPLE
+
+** Usage
+   :PROPERTIES:
+   :CUSTOM_ID: usage
+   :END:
+
+Start with:
+
+#+BEGIN_EXAMPLE
+  resme init
+#+END_EXAMPLE
+
+which generates a YML template for your resume in the current directory.
+Comments in the YML file should help you fill the various entries.
+Notice that most entries are optional and you can remove sections which
+are not relevant for your resume.
+
+You can now generate a resume using one of the existing formats:
+
+#+begin_example
+  resme --to org resume.yml
+#+end_example
+
+Supported formats include:
+
+- =org=: Org Mode format
+- =md=: Markdown format
+- =europass=: Europass format
+  (http://interop.europass.cedefop.europa.eu/web-services/remote-upload/)
+- =json=: JSON format (https://jsonresume.org/)
+
+If you are not satisfied with the provided templates, you can write
+your own (see below).  In this case, however, =resme= is mainly an ERB
+renderer.
+
+Remarks:
+
+- You can specify more than one YML file in input. This allows you to
+  store data about your resume in different files, if you like to do so
+  (e.g., work experiences could be in one file and talks in another).
+  The YML files are merged before processing them.
+- The output filename is optional. If you do not specify one, the resume
+  is generated to =resume-YYYY.MM.DD.format=, where =YYYY-MM-DD= is
+  today's date and =format= is the chosen output format
+
+** Checking validity
+   :PROPERTIES:
+   :CUSTOM_ID: checking-validity
+   :END:
+
+Use the =check= command to verify whether your YAML file conforms with
+the intended syntax.
+
+#+BEGIN_SRC ruby
+  resme check resume.yaml
+#+END_SRC
+
+** Dates in the resume
+   :PROPERTIES:
+   :CUSTOM_ID: dates-in-the-resume
+   :END:
+
+Enter dates in the resume in one of the following formats:
+
+- Any format accepted by Ruby for a full date (year, month, day)
+- YYYY-MM-DD
+- YYYY-MM
+- YYYY
+
+The third and the forth format allows you to enter "partial" dates
+(e.g., when the month or the day have been forgotten or are irrelevant).
+
+** Creating your own templates
+   :PROPERTIES:
+   :CUSTOM_ID: creating-your-own-templates
+   :END:
+
+The resumes are generated from the YML matter using ERB templates. The
+provided output formats should support different back ends (Org Mode
+and Markdown easily allow for generation of PDFs, HTML, and ODT, to
+mention a few).
+
+However, if you want, you can define your own templates.  All the data
+in the resume is made available in the =data= variable.  Thus, for
+instance, the following code snippets generates a list of all the work
+experiences:
+
+#+BEGIN_EXAMPLE
+  <% data.work each do |exp| %>
+  - <%= exp.who %>
+    From: <%=  exp.from %> till: <%= exp.till %>
+  <% end %>
+#+END_EXAMPLE
+
+To specify your own ERB template use the option =-e= (=--erb=). Thus,
+for instance:
+
+#+BEGIN_EXAMPLE
+  $ resme render -e template.md.erb [-o output_filename] file.yaml ...
+#+END_EXAMPLE
+
+uses =template.md.erb= to generate the resume.
+
+Some functions can be used in the templates to better control the
+output.
+
+String manipulation functions:
+
+- =clean string= removes any space at the beginning of =string=
+- =reflow string, n= makes =string= into an array of strings of length
+  lower or equal to =n= (useful if you are outputting a textual format,
+  for instance.
+
+Dates manipulation functions:
+
+- =period= generates a string recapping a period. The function abstracts
+  different syntax you can use for entries (i.e., =date= or =from= and
+  =till=) and different values for the entries (e.g., a missing value
+  for =till=)
+- =year string=, =month string=, =day string= return, respectively the
+  year, month and day from strings in the format =YYYY-MM-DD=s
+- =has_month input= returns true if =input= has a month, that is, it is
+  a date or it is in the form =YYYY-MM=
+- =has_day input= returns true if =input= has a day, that is, it is a
+  date or it is in the form =YYYY-MM-DD=
+
+You can find the templates in =lib/resme/templates=. These might be good
+starting points if you want to develop your own.
+
+** Contributing your templates
+   :PROPERTIES:
+   :CUSTOM_ID: contributing-your-templates
+   :END:
+
+If you develop an output template and want to make it available, please
+let me know, so that I can include it in future releases of this gem.
+
+** Development
+   :PROPERTIES:
+   :CUSTOM_ID: development
+   :END:
+
+After checking out the repo, run =bin/setup= to install dependencies.
+You can also run =bin/console= for an interactive prompt that will allow
+you to experiment.
+
+To install this gem onto your local machine, run
+=bundle exec rake install=. To release a new version, update the version
+number in =version.rb=, and then run =bundle exec rake release=, which
+will create a git tag for the version, push git commits and tags, and
+push the =.gem= file to [[https://rubygems.org][rubygems.org]].
+
+** Contributing
+   :PROPERTIES:
+   :CUSTOM_ID: contributing
+   :END:
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/avillafiorita/resme.
+
+** License
+   :PROPERTIES:
+   :CUSTOM_ID: license
+   :END:
+
+The gem is available as open source under the terms of the
+[[http://opensource.org/licenses/MIT][MIT License]].
+
+** Roadmap
+   :PROPERTIES:
+   :CUSTOM_ID: roadmap
+   :END:
+
+In =doc/todo.org= ... guess what is my preferred editor!
+
+** Bugs
+   :PROPERTIES:
+   :CUSTOM_ID: bugs
+   :END:
+
+There are still slight differences in the syntax of entries and in the
+way in which the information is formatted in various output formats. For
+instance, gender and birthdate are used in the Europass format, but not
+in the Markdown format. This is in part due to the different standards
+and in part due to personal preferences.
+
+*Entries are not sorted by date before outputting them. Make sure you
+put them in the order you want them to appear in your resume.*
+
+Unknown number of unknown bugs.
+
+** Release History
+   :PROPERTIES:
+   :CUSTOM_ID: release-history
+   :END:
+
+- *0.4.0* refactors all generation commands under =generate=, provides
+  new filtering options, adds =-e= option (for custom templates), and
+  refactors various portions of code.  It also revises this document
+  and fixes some minor bugs.
+- *0.3.2* and *0.3.1* fix errors with the Europass format: lists of
+  projects, interests, ... are now properly formatted.
+- *0.3* introduces output to org-mode, introduces references for the CV,
+  improves output to JSON, adds a =check= command, removes useless blank
+  lines in the output, supports =-%>= in the ERB templates, fixes
+  various typos in the documentation, introduces various new formatting
+  functions, to simplify template generation
+- *0.2* improves output of volunteering activities and other information
+  in the Europass and *significantly improves error and warning
+  reporting*
+- *0.1* is the first release

data/exe/resme

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'resme'
+require "resme"
 
 # read-eval-print-step passing all commands and the argument
-Resme::CommandSemantics.reps Resme::CommandSyntax.commands, ARGV
+Resme::CommandSemantics.execute Resme::CommandSyntax.commands, ARGV

data/lib/resme/cli/command_semantics.rb

@@ -1,90 +1,90 @@
-require 'resme/version'
-require 'readline'
-require 'fileutils'
-require 'date'
-require 'yaml'
-require 'erb'
-require 'json'
-require 'kwalify'
+require "resme/version"
+require "readline"
+require "fileutils"
+require "date"
+require "yaml"
+require "erb"
+require "json"
+require "kwalify"
 
 module Resme
   module CommandSemantics
-    APPNAME = 'resme'
+    APPNAME = "resme"
     VERSION = Resme::VERSION
 
     #
     # Main App Starts Here!
     #
-    def self.version opts = nil, argv = []
+    def self.version(opts = nil, argv = [])
       puts "#{APPNAME} version #{VERSION}"
     end
 
-    def self.man opts = nil, argv = []
-      path = File.join(File.dirname(__FILE__), "/../../../README.md")
+    def self.man(opts = nil, argv = [])
+      path = File.join(File.dirname(__FILE__), "/../../../README.org")
       file = File.open(path, "r")
-      contents = file.read
-      puts contents
+      puts file.read
     end
 
-    def self.help opts = nil, argv = []
+    def self.help(opts = nil, argv = [])
       all_commands = CommandSyntax.commands
       
       if argv != []
-        argv.map { |x| puts all_commands[x.to_sym][2] }
+        argv.map do |x|
+          puts all_commands[x.to_sym][:help]
+          puts "\n\n"
+        end
       else
-        puts "#{APPNAME} command [options] [args]"
-        puts ""
-        puts "Available commands:"
-        puts ""
-        all_commands.keys.each do |key|
-          puts "  " + all_commands[key][0].banner
+        puts "#{APPNAME} command [options] [args]\n"
+        puts "Available commands:\n"
+        all_commands.each_key do |key|
+          puts "  #{all_commands[key][:options].banner}"
         end
       end
     end
 
-    def self.console opts, argv = []
+    def self.console(opts, argv = [])
       all_commands = CommandSyntax.commands
       all_commands.delete(:console)
       
       i = 0
       while true
         string = Readline.readline("#{APPNAME}:%03d> " % i, true)
-        string.gsub!(/^#{APPNAME} /, "") # as a courtesy, remove any leading appname string
-        if string == "exit" or string == "quit" or string == "." then
-          exit 0
-        end
-        reps all_commands, string.split(' ')
+        # as a courtesy, remove any leading appname string
+        string.gsub!(/^#{APPNAME} /, "")
+        exit 0 if %w[exit quit .].include? string
+        execute all_commands, string.split(" ")
         i = i + 1
       end
     end
 
     # read-eval-print step
-    def self.reps all_commands, argv
+    # check if argv is in any of all_commands, parse options
+    # according to the specification in all_commands and invoke
+    # a function in this class to actually do the work
+    def self.execute(all_commands, argv)
       if argv == [] or argv[0] == "--help" or argv[0] == "-h"
-        CommandSemantics.help
+        help
         exit 0
       else
         command = argv[0]
-        syntax_and_semantics = all_commands[command.to_sym]
-        if syntax_and_semantics
-          opts = syntax_and_semantics[0]
-          function = syntax_and_semantics[1]
-          
-          begin
-            parser = Slop::Parser.new(opts)
+        command_spec = all_commands[command.to_sym]
 
-            result = parser.parse(argv[1..-1])
-            options = result.to_hash
-            arguments = result.arguments
+        if command_spec
+          command_name = command_spec[:name]
+          option_parser = command_spec[:options]
 
-            eval "CommandSemantics::#{function}(options, arguments)"
-          rescue Slop::Error => e
-            puts "#{APPNAME}: #{e}"
+          begin
+            argv.shift # remove command name from ARGV
+            options = {}
+            parser = option_parser.parse!(into: options)
+            eval "CommandSemantics::#{command_name}(options, argv)"
           rescue Exception => e
-            puts e
+            puts "#{APPNAME} error: #{e}"
+            puts "Help with \"#{APPNAME} help #{command_name}\""
           end
         else
-          puts "#{APPNAME}: '#{command}' is not a valid command. See '#{APPNAME} help'"
+          puts "#{APPNAME} error: "#{command}" is not a valid command."
+          puts "List commands with \"#{APPNAME} help\"."
         end
       end
     end
@@ -92,23 +92,18 @@ module Resme
     #
     # APP SPECIFIC COMMANDS
     #
-    def self.check opts, argv
-      schema = Kwalify::Yaml.load_file(File.join(File.dirname(__FILE__), "/../templates/schema.yml"))
-      ## or
-      # schema = YAML.load_file('schema.yaml')
+    def self.check(opts, argv)
+      path = File.join(File.dirname(__FILE__), "/../templates/schema.yml")
+      schema = Kwalify::Yaml.load_file(path)
 
-      ## create validator
+      # create validator
       validator = Kwalify::Validator.new(schema)
-
-      ## load document
+      # load document
       document = Kwalify::Yaml.load_file(argv[0])
-      ## or
-      #document = YAML.load_file('document.yaml')
-
-      ## validate
+      # validate
       errors = validator.validate(document)
 
-      ## show errors
+      # show errors
       if errors && !errors.empty?
         for e in errors
           puts "[#{e.path}] #{e.message}"
@@ -118,14 +113,16 @@ module Resme
       end
     end
 
-    def self.init opts, argv
+    def self.init(opts, argv)
       output = opts[:output] || "resume.yml"
       force = opts[:force]
-      template = File.join(File.dirname(__FILE__), "/../templates/resume.yml")
+      path = File.dirname(__FILE__), "/../templates/resume.yml"
+      template = File.join(path)
 
-      # avoid catastrophy
-      if File.exist?(output) and not force
-        puts "Error: file #{output} already exists.  Use --force if you want to overwrite it"
+      # avoid catastrophe
+      if File.exist?(output) && !force
+        puts "#{APPNAME} error: file #{output} already exists."
+        puts "Use --force if you want to overwrite it."
       else
         content = File.read(template)
         backup_and_write output, content
@@ -133,60 +130,65 @@ module Resme
       end
     end
 
-    def self.md opts, argv
-      output = opts[:output] || "resume-#{Date.today}.md"
-      template = File.join(File.dirname(__FILE__), "/../templates/resume.md.erb")
-
-      render argv, template, output
-      puts "Resume generated in #{output}"
+    def self.list(opts, argv)
+      data = {}
+      argv.each do |file|
+        data = data.merge(YAML.load_file(file, permitted_classes: [Date]))
+      end
+      puts "Sections included in #{argv.join(", ")}:"
+      data.keys.each do |key|
+        puts "- #{key}: #{(data[key] || []).size} entries"
+      end
     end
 
-    def self.org opts, argv
-      output = opts[:output] || "resume-#{Date.today}.org"
-      template = File.join(File.dirname(__FILE__), "/../templates/resume.org.erb")
+    def self.generate(opts, argv)
+      format = opts[:to] == "europass" ? "xml" : opts[:to]
+      output = opts[:output] || "resume-#{Date.today}.#{format}"
 
-      render argv, template, output
-      puts "Resume generated in #{output}"
-    end
-
-    def self.json opts, argv
-      output = opts[:output] || "resume-#{Date.today}.json"
-      template = File.join(File.dirname(__FILE__), "/../templates/resume.json.erb")
+      if opts[:erb]
+        template = opts[:erb]
+      else
+        template = File.join(File.dirname(__FILE__), "/../templates/resume.#{format}.erb")
+      end
 
-      render argv, template, output
-      puts "Resume generated in #{output}"
-    end
+      skipped_sections = opts[:skip] || []
 
-    def self.europass opts, argv
-      output = opts[:output] || "resume-#{Date.today}.xml"
-      template = File.join(File.dirname(__FILE__), "/../templates/europass/eu.xml.erb")
+      if !File.exists?(template)
+        puts "#{APPNAME} error: format #{format} is not understood."
+      end
 
-      render argv, template, output
+      render argv, template, output, skipped_sections
       puts "Resume generated in #{output}"
-      puts "Render via, e.g., http://interop.europass.cedefop.europa.eu/web-services/remote-upload/"
+
+      if format == "xml" then
+        puts "Europass XML generated. Render via, e.g., http://interop.europass.cedefop.europa.eu/web-services/remote-upload/"
+      end
     end
 
     private
 
-    def self.render yml_files, template_filename, output_filename
-      data = Hash.new
+    def self.render(yml_files, template_name, output_name, skipped_sections)
+      data = {}
       yml_files.each do |file|
-        data = data.merge(YAML.load_file(file))
+        data = data.merge(YAML.load_file(file, permitted_classes: [Date]))
+      end
+      skipped_sections.each do |section|
+        data.reject! { |k| k == section } 
       end
-      template = File.read(template_filename)
-      output = ERB.new(template, nil, '-').result(binding)
+      template = File.read(template_name)
+      output = ERB.new(template, trim_mode: "-").result(binding)
       # it is difficult to write readable ERBs with no empty lines...
       # we use gsub to replace multiple empty lines with \n\n in the final output
       output.gsub!(/([\t ]*\n){3,}/, "\n\n")
-      backup_and_write output_filename, output
+      backup_and_write output_name, output
     end
 
-    def self.backup filename
+    def self.backup(filename)
       FileUtils::cp filename, filename + "~"
       puts "Backup copy #{filename} created in #{filename}~."
     end
 
-    def self.backup_and_write filename, content
+    def self.backup_and_write(filename, content)
       backup(filename) if File.exist?(filename)
       File.open(filename, "w") { |f| f.puts content }
     end