resme 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c7490069bf046c56808342ad427c9f055bba680506486029770761517b92099
-  data.tar.gz: eb69e1752e4b4f4564e0e8cf9c7f5fa65756f7b3e599073a52d8c49583084776
+  metadata.gz: d8abd7d17f0d2b9a777cba680826c21d6ee882f3f3df0c74ba086e1d617d4b6b
+  data.tar.gz: b34b33c2f2d0f3beae3bef713efba2e39b05537d8a208380e6392271e0cbcb09
 SHA512:
-  metadata.gz: cb0ac162ee646457be8d70f51359de1e7d2ad99ad545c79d1403f565c220e975e5927b0ab2fb00c72346edff04ccc0143282d666a08034f2174e7fe770cefc50
-  data.tar.gz: 3eb1f599f8ca2abbf274632c3afa0076349a85bc44e7c1b468761112627a086aa5de5385a5d4f79a2f6f438fe343b8f5c8de2979dc1bdacbc10ee7a72a258abb
+  metadata.gz: fe74aa311a4dd110c26a0760cf6d2f8cb1ba1ee8e587f2a64d00ff6aa420a2a7f6c37b1eec392ddf1b28abbe49ffb94d6b26d5f43f2797ba9fd7cc9874ebf5c1
+  data.tar.gz: 3f2ae60c5c8a4e7f8135aa7f43aafa081f913dc8dd6c1b4c6065606447a41b6afe414ae4f32e0541fc06284227d94628f31f59e80af02aee2147c054032137c8

data/README.org

@@ -3,13 +3,8 @@
 #+DATE: <2020-07-14 Tue>
 #+STARTUP: showall
 
-* RESME - A Resume Generator
-  :PROPERTIES:
-  :CUSTOM_ID: resme---a-resume-generator
-  :END:
-
 Keep your resume in YAML and output it in various formats, including
-org-mode, markdown, json, and the Europass XML format.
+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
@@ -46,41 +41,39 @@ Or install it yourself as:
 Start with:
 
 #+BEGIN_EXAMPLE
-  $ resme init
+  resme init
 #+END_EXAMPLE
 
-whih generates a YML template for your resume in the current directory.
+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 then generate a resume using one of the existing templates or by
-writing your own template (see below).
-
-To generate a resume in Markdown using the provided template:
-
-$ resme org [-o output_filename] file.yml ...
+You can now generate a resume using one of the existing formats:
 
-To generate a resume in Markdown using the provided template:
+#+begin_example
+  resme --to org resume.yml
+#+end_example
 
-$ resme md [-o output_filename] file.yml ...
+Supported formats include:
 
-To generate a resume in the Europass XML format using the provided
-template:
+- =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/)
 
-$ resme europass [-o output_filename] file.yml ...
-
-To generate a resume in the JSON format (https://jsonresume.org/):
-
-$ resme json [-o output_filename] file.yaml ...
+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
+- 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
+- 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
 
@@ -117,14 +110,14 @@ The third and the forth format allows you to enter "partial" dates
    :END:
 
 The resumes are generated from the YML matter using ERB templates. The
-output formats should support different backends (OrgMode and Markdown
-easily allow for generation of PDFs, HTML, and ODT to mention a few).
-
-You can define your own templates if you wish to do so.
+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).
 
-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:
+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| %>
@@ -133,11 +126,11 @@ the work experiences:
   <% end %>
 #+END_EXAMPLE
 
-To specify your own ERB template use the option =-t=. Thus, for
-instance:
+To specify your own ERB template use the option =-e= (=--erb=). Thus,
+for instance:
 
 #+BEGIN_EXAMPLE
-  $ resme render -t template.md.erb [-o output_filename] file.yaml ...
+  $ resme render -e template.md.erb [-o output_filename] file.yaml ...
 #+END_EXAMPLE
 
 uses =template.md.erb= to generate the resume.
@@ -235,6 +228,10 @@ Unknown number of unknown bugs.
    :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,

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