resme 2.0.0 → 2.1.0

data/lib/resme/executor.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module Resme
+  #
+  # Execute!
+  #
   class Executor
     # include all formatter helpers
     include Resme::Helper
@@ -11,12 +14,13 @@ module Resme
       @options.parse
     end
 
+    # rubocop:disable Metrics
     def execute
       case @options.command
       when :init
         resume_template = File.join __dir__, "../../templates/resume.yml"
         puts File.read resume_template
-        
+
       when :validate
         filename = @options.options[:filename]
         document = Document.new(filename)
@@ -26,7 +30,7 @@ module Resme
       when :sections
         filename = @options.options[:filename]
         keys = Document.new(filename).data.keys
-        puts keys 
+        puts keys
 
       when :build
         filename = @options.options[:filename]
@@ -40,23 +44,41 @@ module Resme
         template = File.read(template_name)
 
         # add the json format, if specified
-        if format.to_s == "json"
+        if format.to_s.downcase == "json"
           js = JsonResume.new Document.new(filename)
           @json_resume = js.build
         end
-        
-        output = ERB.new(template, trim_mode: "-").result(binding)
 
+        # copy the theme and set it in data for the tempalte, if output is html
+        if format.to_s.downcase == "html"
+          css_filename = theme_css_file @options.options[:theme]
+          css_template = File.join __dir__, "../../templates/#{css_filename}"
+          FileUtils.cp css_template, css_filename
+
+          @data[:theme] = css_filename
+        end
+
+        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(format), output)
+
+        output_filename = output_filename(format)
+        backup_and_write(output_filename, output)
+        puts "Resume generated and saved to #{output_filename}"
 
       when :list
         templates = File.join __dir__, "../../templates/*.erb"
         files = Dir.glob(templates).map { |x| "#{File.basename(x)} => #{x}" }
         puts files.join("\n")
 
+      when :themes
+        templates = File.join __dir__, "../../templates/*.css"
+        files = Dir.glob(templates).map do |x|
+          File.basename(x).gsub("resume-", "").gsub(".css", "")
+        end
+        puts files.join("\n")
+
       when :cat
         template = @options.options[:template]
         template_path = File.join __dir__, "../../templates/#{template}"
@@ -70,15 +92,20 @@ module Resme
 
       end
     end
+    # rubocop:enable Metrics
 
     private
 
+    def theme_css_file(theme_name)
+      "resume-#{theme_name}.css"
+    end
+
     def output_filename(format)
       "resume-#{Date.today.iso8601}.#{format}"
     end
 
     def backup(filename)
-      FileUtils::cp filename, filename + "~"
+      FileUtils.cp filename, "#{filename}~"
       puts "Backup copy #{filename} created in #{filename}~."
     end
 

data/lib/resme/helper.rb

@@ -14,7 +14,7 @@ module Resme
       [
         data.dig(:basics, :first_name),
         data.dig(:basics, :middle_name),
-        data.dig(:basics, :last_name),
+        data.dig(:basics, :last_name)
       ].compact.join(" ")
     end
 
@@ -30,6 +30,7 @@ module Resme
     # Special cases: if one line is longer than chars characters, then break at
     # the first space after chars
     #
+    # rubocop:disable Metrics/AbcSize
     def reflow_a(string, line_break: 78)
       # if the string is less than line_break chars, we are done
       return [clean(string)] if string.length < line_break
@@ -45,7 +46,7 @@ module Resme
                  reflow_a(string[(index + 1)..], line_break:)
         end
       end
-      
+
       # here the string does not have a space between 0 and line_break
       #
       # In this case we try to break at the first blank after the string and
@@ -57,18 +58,19 @@ module Resme
                  reflow_a(string[(index + 1)..], line_break:)
         end
       end
-      
+
       # here string is longer than line_break and it does not have spaces
       #
       # The only thing left to do is returning the string as it is
       #
       [clean(string)]
     end
+    # rubocop:enable Metrics/AbcSize
 
     def blank?(char)
       [" ", "\t", "\n"].include?(char)
     end
-       
+
     # Reflow at +line_break+, returning a string with each line delimited by
     # +delimiter+ (by default newline) and indented with +indent+ spaces.
     #
@@ -148,11 +150,16 @@ module Resme
       contact ? contact[:value] : nil
     end
 
+    # break text into paragraphs and wrap in <p>
+    def html_summary(text)
+      text.split("\n\n").map { |x| "<p>#{x}</p>" }.join
+    end
+
     #
     # Utility functions for managing dates in the form 2015-01-01 and partial
     # dates (e.g., 2015-05, 2015)
     #
-    
+
     # Format the input as a date, according to format.  If the input is not
     # a date, return it as it (assuming it represents a partial date (e.g.,
     # 2012-01, 2012
@@ -172,8 +179,6 @@ module Resme
         "#{incomplete_date}-01"
       elsif y?(incomplete_date.to_s)
         "#{incomplete_date}-01-01"
-      else
-        nil
       end
     end
 
@@ -191,7 +196,7 @@ module Resme
     def day(input)
       input.is_a?(Date) ? input.strftime("%d") : input.to_s[8..9]
     end
-    
+
     # Is the input in the form YYYY-MM(-..)
     def y?(input)
       input.is_a?(Date) || input.to_s.size == 4
@@ -208,4 +213,3 @@ module Resme
     end
   end
 end
-

data/lib/resme/json_resume.rb

@@ -6,151 +6,154 @@ module Resme
   #
   class JsonResume
     include Helper
-    
+
     def initialize(document)
       @document = document
       @data = document.data
     end
 
+    # rubocop:disable Metrics
     def build
       address = @data[:addresses]&.first || {}
-      
+      education = @data[:education].select { |x| x[:publish] } || []
+
       {
-        "basics": {
-          "name": full_name(@data),
-          "label": @data[:basics][:title],
-          "image": "",
-          "email": select(@data[:contacts], label: :email),
-          "phone": select(@data[:contacts], label: :phone),
-          "url": select(@data[:web_presence], label: :url),
-          "summary": @data[:summary],
-          "location": {
-            "address": address[:street],
-            "postalCode": address[:postal_code].to_s,
-            "city": address[:city],
-            "countryCode": address[:country_code],
-            "region": address[:region]
+        basics: {
+          name: full_name(@data),
+          label: @data[:basics][:title],
+          image: "",
+          email: select(@data[:contacts], label: :email),
+          phone: select(@data[:contacts], label: :phone),
+          url: select(@data[:web_presence], label: :url),
+          summary: @data[:summary],
+          location: {
+            address: address[:street],
+            postalCode: address[:postal_code].to_s,
+            city: address[:city],
+            countryCode: address[:country_code],
+            region: address[:region]
           }.compact,
-          "profiles": @data[:web_presence].map do |kv|
+          profiles: @data[:web_presence].map do |kv|
             {
-              "network": kv[:label],
-              "username": kv[:value],
-              # "url":
+              network: kv[:label],
+              username: kv[:value]
+              # url:
             }
           end.compact
         }.compact,
 
-        "work": @data[:work].map do |job|
+        work: @data[:work].map do |elem|
           {
-            "name": job[:name],
-            "position": job[:position],
-            "url": job[:url],
-            "startDate": complete_date(job[:date] || job[:start_date]),
-            "endDate": complete_date(job[:date] || job[:end_date]),
-            "summary": job[:summary],
-            "highlights": split_highlights(job[:details])
+            name: elem[:name],
+            position: elem[:position],
+            url: elem[:url],
+            startDate: complete_date(elem[:date] || elem[:start_date]),
+            endDate: complete_date(elem[:date] || elem[:end_date]),
+            summary: elem[:summary],
+            highlights: split_highlights(elem[:details])
           }.compact
         end,
 
-        "volunteer": (@data[:volunteer] || []).map do |job|
+        volunteer: (@data[:volunteer] || []).map do |elem|
           {
-            "organization": job[:name],
-            "position": job[:position],
-            "startDate": complete_date(job[:date] || job[:start_date]),
-            "endDate": complete_date(job[:date] || job[:end_date]),
-            "summary": job[:summary],
-            "highlights": split_highlights(job[:details])
+            organization: elem[:name],
+            position: elem[:position],
+            startDate: complete_date(elem[:date] || elem[:start_date]),
+            endDate: complete_date(elem[:date] || elem[:end_date]),
+            summary: elem[:summary],
+            highlights: split_highlights(elem[:details])
           }.compact
         end,
 
-        "education": (@data[:education].select { |x| x[:publish] } || []).map do |job|
+        education: education.map do |elem|
           {
-            "institution": job[:school],
-            "url": job[:url],
-            "area": job[:topic],
-            "studyType": job[:degree],
-            "startDate": complete_date(job[:date] || job[:start_date]),
-            "endDate": complete_date(job[:date] || job[:end_date]),
-            "score": job[:score],
-            "courses": []
+            institution: elem[:school],
+            url: elem[:url],
+            area: elem[:topic],
+            studyType: elem[:degree],
+            startDate: complete_date(elem[:date] || elem[:start_date]),
+            endDate: complete_date(elem[:date] || elem[:end_date]),
+            score: elem[:score],
+            courses: []
           }.compact
         end,
 
-        "awards": (@data[:awards] || []).map do |job|
+        awards: (@data[:awards] || []).map do |elem|
           {
-            "title": job[:title],
-            "date": complete_date(job[:date]),
-            "awarder": job[:name],
-            "summary": job[:summary]
+            title: elem[:title],
+            date: complete_date(elem[:date]),
+            awarder: elem[:name],
+            summary: elem[:summary]
           }.compact
         end,
 
-        "certificates": [],
+        certificates: [],
 
-        "publications": (@data[:publications] || []).map do |job|
+        publications: (@data[:publications] || []).map do |elem|
           {
-            "name": [job[:title], job[:authors]].compact.join(", "),
-            "publisher": job[:publisher],
-            "releaseDate": complete_date(job[:date]),
-            "url": job[:url],
-            "summary": ""
+            name: [elem[:title], elem[:authors]].compact.join(", "),
+            publisher: elem[:publisher],
+            releaseDate: complete_date(elem[:date]),
+            url: elem[:url],
+            summary: ""
           }.compact
         end,
-        
-        "skills": (@data[:skills] || []).map do |job|
+
+        skills: (@data[:skills] || []).map do |elem|
           {
-            "name": job[:name],
-            "level": job[:level],
-            "keywords": split_highlights(job[:summary])
+            name: elem[:name],
+            level: elem[:level],
+            keywords: split_highlights(elem[:summary])
           }.compact
         end,
-        
-        "languages": (@data.dig(:languages, :mother_tongues) || []).map do |job|
-          { 
-            "language": job[:language],
-            "fluency": "Native speaker"
+
+        languages: (@data.dig(:languages, :mother_tongues) || []).map do |elem|
+          {
+            language: elem[:language],
+            fluency: "Native speaker"
           }.compact
-        end + (@data.dig(:languages, :foreign) || []).map do |job|
-          { 
-            "language": job[:language],
-            "fluency": job[:level]
+        end + (@data.dig(:languages, :foreign) || []).map do |elem|
+          {
+            language: elem[:language],
+            fluency: elem[:level]
           }.compact
         end,
 
-        "interests": (@data[:interests] || []).map do |job|
+        interests: (@data[:interests] || []).map do |elem|
           {
-            "name": job[:name],
-            "keywords": split_highlights(job[:summary])
+            name: elem[:name],
+            keywords: split_highlights(elem[:summary])
           }.compact
         end,
-        
-        "references": (@data[:references] || []).map do |job|
+
+        references: (@data[:references] || []).map do |elem|
           {
-            "name": job[:name],
-            "reference": job[:reference]
+            name: elem[:name],
+            reference: elem[:reference]
           }.compact
         end,
-        
-        "projects": (@data[:projects] || []).map do |job|
+
+        projects: (@data[:projects] || []).map do |elem|
           {
-            "name": job[:name],
-            "url": job[:url],
-            "startDate": complete_date(job[:date] || job[:start_date]),
-            "endDate": complete_date(job[:date] || job[:end_date]),
-            "description": job[:summary],
-            "highlights": []
+            name: elem[:name],
+            url: elem[:url],
+            startDate: complete_date(elem[:date] || elem[:start_date]),
+            endDate: complete_date(elem[:date] || elem[:end_date]),
+            description: elem[:summary],
+            highlights: []
           }.compact
         end
       }.compact
     end
+    # rubocop:enable Metrics
 
     private
 
     # make a string with an itemized list into an array of the items
     def split_highlights(highlights)
       (highlights || "").split(/^ *- /)
-        .map { |x| x.gsub("\n", "") }
-        .reject { |x| x == "" }
+                        .map { |x| x.gsub("\n", "") }
+                        .reject { |x| x == "" }
     end
   end
 end

data/lib/resme/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Resme
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/lib/resme.rb

@@ -16,5 +16,3 @@ require_relative "resme/document"
 require_relative "resme/document_validator"
 require_relative "resme/json_resume"
 require_relative "resme/executor"
-require_relative "resme/version"
-